Merge branch 'master' into generic

Conflicts:
	releng/org.eclipse.emf.diffmerge.target/org.eclipse.emf.diffmerge.target.target


Change-Id: I41c8b1921fbe39400be8ace4dea364c0cada1088
Signed-off-by: Olivier Constant <olivier.constant@thalesgroup.com>
diff --git a/doc/org.eclipse.emf.diffmerge.doc/META-INF/MANIFEST.MF b/doc/org.eclipse.emf.diffmerge.doc/META-INF/MANIFEST.MF
index a30e735..a49cec9 100644
--- a/doc/org.eclipse.emf.diffmerge.doc/META-INF/MANIFEST.MF
+++ b/doc/org.eclipse.emf.diffmerge.doc/META-INF/MANIFEST.MF
@@ -6,6 +6,6 @@
 Bundle-Vendor: %providerName
 Require-Bundle: org.eclipse.ui,
  org.eclipse.core.runtime
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Bundle-ActivationPolicy: lazy
 Bundle-Localization: plugin
diff --git a/features/org.eclipse.emf.diffmerge.feature/feature.xml b/features/org.eclipse.emf.diffmerge.feature/feature.xml
index 9ce025f..e97f63e 100644
--- a/features/org.eclipse.emf.diffmerge.feature/feature.xml
+++ b/features/org.eclipse.emf.diffmerge.feature/feature.xml
@@ -23,7 +23,7 @@
    </description>
 
    <copyright>
-       %copyright
+      %copyright
    </copyright>
 
    <license url="%licenseURL">
@@ -65,4 +65,18 @@
          version="0.0.0"
          unpack="false"/>
 
+   <plugin
+         id="org.eclipse.emf.diffmerge.generic"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.emf.diffmerge.pojo"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
 </feature>
diff --git a/plugins/org.eclipse.emf.diffmerge.connector.core/.classpath b/plugins/org.eclipse.emf.diffmerge.connector.core/.classpath
index 4c62a80..4f83b23 100644
--- a/plugins/org.eclipse.emf.diffmerge.connector.core/.classpath
+++ b/plugins/org.eclipse.emf.diffmerge.connector.core/.classpath
@@ -2,6 +2,6 @@
 <classpath>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
 	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/plugins/org.eclipse.emf.diffmerge.connector.core/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.emf.diffmerge.connector.core/.settings/org.eclipse.jdt.core.prefs
index 966ac18..bb1c555 100644
--- a/plugins/org.eclipse.emf.diffmerge.connector.core/.settings/org.eclipse.jdt.core.prefs
+++ b/plugins/org.eclipse.emf.diffmerge.connector.core/.settings/org.eclipse.jdt.core.prefs
@@ -16,9 +16,9 @@
 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.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.8
 org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 org.eclipse.jdt.core.compiler.debug.localVariable=generate
 org.eclipse.jdt.core.compiler.debug.sourceFile=generate
@@ -120,7 +120,7 @@
 org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=warning
 org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
 org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.8
 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
diff --git a/plugins/org.eclipse.emf.diffmerge.connector.core/META-INF/MANIFEST.MF b/plugins/org.eclipse.emf.diffmerge.connector.core/META-INF/MANIFEST.MF
index c2d8ae1..87ce48f 100644
--- a/plugins/org.eclipse.emf.diffmerge.connector.core/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.emf.diffmerge.connector.core/META-INF/MANIFEST.MF
@@ -14,7 +14,7 @@
 Bundle-Vendor: %providerName
 Bundle-ActivationPolicy: lazy
 Bundle-Activator: org.eclipse.emf.diffmerge.connector.core.EMFDiffMergeCoreConnectorPlugin
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Export-Package: org.eclipse.emf.diffmerge.connector.core,
  org.eclipse.emf.diffmerge.connector.core.ext
 Automatic-Module-Name: org.eclipse.emf.diffmerge.connector.core
diff --git a/plugins/org.eclipse.emf.diffmerge.connector.core/src/org/eclipse/emf/diffmerge/connector/core/ext/TeamComparisonViewer.java b/plugins/org.eclipse.emf.diffmerge.connector.core/src/org/eclipse/emf/diffmerge/connector/core/ext/TeamComparisonViewer.java
index d1c4808..03aa053 100644
--- a/plugins/org.eclipse.emf.diffmerge.connector.core/src/org/eclipse/emf/diffmerge/connector/core/ext/TeamComparisonViewer.java
+++ b/plugins/org.eclipse.emf.diffmerge.connector.core/src/org/eclipse/emf/diffmerge/connector/core/ext/TeamComparisonViewer.java
@@ -27,9 +27,9 @@
 import org.eclipse.compare.contentmergeviewer.IFlushable;
 import org.eclipse.compare.structuremergeviewer.ICompareInput;
 import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.emf.diffmerge.api.Role;
 import org.eclipse.emf.diffmerge.connector.core.EMFDiffMergeCoreConnectorPlugin;
 import org.eclipse.emf.diffmerge.connector.core.Messages;
+import org.eclipse.emf.diffmerge.generic.api.Role;
 import org.eclipse.emf.diffmerge.ui.EMFDiffMergeUIPlugin;
 import org.eclipse.emf.diffmerge.ui.setup.ComparisonSetup;
 import org.eclipse.emf.diffmerge.ui.setup.ComparisonSetupManager;
@@ -193,7 +193,7 @@
     EMFDiffMergeEditorInput result = null;
     ComparisonSetup setup = createSetup(manager_p, left_p, right_p, ancestor_p);
     if (setup != null) {
-      IComparisonMethod method = setup.getComparisonMethod();
+      IComparisonMethod<?> method = setup.getComparisonMethod();
       if (method != null) {
         if (method.isConfigurable()) {
           // Setting comparison method to gconf configuration if applicable
diff --git a/plugins/org.eclipse.emf.diffmerge.connector.core/src/org/eclipse/emf/diffmerge/connector/core/ext/URIConvertingScopeDefinition.java b/plugins/org.eclipse.emf.diffmerge.connector.core/src/org/eclipse/emf/diffmerge/connector/core/ext/URIConvertingScopeDefinition.java
index 15f9546..8e1de47 100644
--- a/plugins/org.eclipse.emf.diffmerge.connector.core/src/org/eclipse/emf/diffmerge/connector/core/ext/URIConvertingScopeDefinition.java
+++ b/plugins/org.eclipse.emf.diffmerge.connector.core/src/org/eclipse/emf/diffmerge/connector/core/ext/URIConvertingScopeDefinition.java
@@ -14,9 +14,9 @@
 
 import java.io.InputStream;
 
-import org.eclipse.emf.diffmerge.api.scopes.IEditableModelScope;
 import org.eclipse.emf.diffmerge.api.scopes.IPersistentModelScope;
-import org.eclipse.emf.diffmerge.impl.scopes.AbstractModelScope;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope;
+import org.eclipse.emf.diffmerge.generic.impl.scopes.AbstractDataScope;
 import org.eclipse.emf.diffmerge.ui.specification.IModelScopeDefinition;
 import org.eclipse.emf.diffmerge.ui.specification.ITimestampProvider;
 import org.eclipse.emf.ecore.resource.Resource;
@@ -60,18 +60,21 @@
   /**
    * @see org.eclipse.emf.diffmerge.ui.specification.IModelScopeDefinition#createScope(java.lang.Object)
    */
-  public IEditableModelScope createScope(Object context_p) {
-    IEditableModelScope result;
-    if (_editable)
+  public IEditableTreeDataScope<?> createScope(Object context_p) {
+    IEditableTreeDataScope<?> result;
+    if (_editable) {
       result = _wrapped.createScope(context_p); // Use the same context for editable contents
-    else
+    } else {
       result = _wrapped.createScope(null); // Ignore context for a fresh resource set
-    if (result instanceof AbstractModelScope)
-      ((AbstractModelScope)result).setOriginator(_wrapped.getLabel());
+    }
+    if (result instanceof AbstractDataScope<?>) {
+      ((AbstractDataScope<?>)result).setOriginator(_wrapped.getLabel());
+    }
     if (result instanceof IPersistentModelScope) {
       IPersistentModelScope casted = (IPersistentModelScope)result;
-      if (_loadingStream != null && casted instanceof IPersistentModelScope.Editable)
+      if (_loadingStream != null && casted instanceof IPersistentModelScope.Editable) {
         ((IPersistentModelScope.Editable)casted).setStream(_loadingStream);
+      }
       Resource holdingResource = casted.getHoldingResource();
       if (holdingResource != null) {
         ResourceSet rs = holdingResource.getResourceSet();
diff --git a/plugins/org.eclipse.emf.diffmerge.connector.git/.classpath b/plugins/org.eclipse.emf.diffmerge.connector.git/.classpath
index 4c62a80..4f83b23 100644
--- a/plugins/org.eclipse.emf.diffmerge.connector.git/.classpath
+++ b/plugins/org.eclipse.emf.diffmerge.connector.git/.classpath
@@ -2,6 +2,6 @@
 <classpath>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
 	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/plugins/org.eclipse.emf.diffmerge.connector.git/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.emf.diffmerge.connector.git/.settings/org.eclipse.jdt.core.prefs
index 966ac18..bb1c555 100644
--- a/plugins/org.eclipse.emf.diffmerge.connector.git/.settings/org.eclipse.jdt.core.prefs
+++ b/plugins/org.eclipse.emf.diffmerge.connector.git/.settings/org.eclipse.jdt.core.prefs
@@ -16,9 +16,9 @@
 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.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.8
 org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 org.eclipse.jdt.core.compiler.debug.localVariable=generate
 org.eclipse.jdt.core.compiler.debug.sourceFile=generate
@@ -120,7 +120,7 @@
 org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=warning
 org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
 org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.8
 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
diff --git a/plugins/org.eclipse.emf.diffmerge.connector.git/META-INF/MANIFEST.MF b/plugins/org.eclipse.emf.diffmerge.connector.git/META-INF/MANIFEST.MF
index 7227dd6..228390d 100644
--- a/plugins/org.eclipse.emf.diffmerge.connector.git/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.emf.diffmerge.connector.git/META-INF/MANIFEST.MF
@@ -16,7 +16,7 @@
 Bundle-Vendor: %providerName
 Bundle-ActivationPolicy: lazy
 Bundle-Activator: org.eclipse.emf.diffmerge.connector.git.EMFDiffMergeGitConnectorPlugin
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Export-Package: org.eclipse.emf.diffmerge.connector.git,
  org.eclipse.emf.diffmerge.connector.git.ext
 Automatic-Module-Name: org.eclipse.emf.diffmerge.connector.git
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/.classpath b/plugins/org.eclipse.emf.diffmerge.generic/.classpath
new file mode 100644
index 0000000..4f83b23
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/.project b/plugins/org.eclipse.emf.diffmerge.generic/.project
new file mode 100644
index 0000000..499693a
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.emf.diffmerge.generic</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.diffmerge.generic/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.emf.diffmerge.generic/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bf5eac1
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,409 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.codeComplete.argumentPrefixes=
+org.eclipse.jdt.core.codeComplete.argumentSuffixes=_p
+org.eclipse.jdt.core.codeComplete.fieldPrefixes=_
+org.eclipse.jdt.core.codeComplete.fieldSuffixes=
+org.eclipse.jdt.core.codeComplete.localPrefixes=
+org.eclipse.jdt.core.codeComplete.localSuffixes=
+org.eclipse.jdt.core.codeComplete.staticFieldPrefixes=__
+org.eclipse.jdt.core.codeComplete.staticFieldSuffixes=
+org.eclipse.jdt.core.codeComplete.staticFinalFieldPrefixes=
+org.eclipse.jdt.core.codeComplete.staticFinalFieldSuffixes=
+org.eclipse.jdt.core.compiler.annotation.inheritNullAnnotations=disabled
+org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation=ignore
+org.eclipse.jdt.core.compiler.annotation.nonnull=org.eclipse.jdt.annotation.NonNull
+org.eclipse.jdt.core.compiler.annotation.nonnull.secondary=
+org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annotation.NonNullByDefault
+org.eclipse.jdt.core.compiler.annotation.nonnullbydefault.secondary=
+org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
+org.eclipse.jdt.core.compiler.annotation.nullable.secondary=
+org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+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.doc.comment.support=enabled
+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=warning
+org.eclipse.jdt.core.compiler.problem.deadCode=warning
+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=warning
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=ignore
+org.eclipse.jdt.core.compiler.problem.fallthroughCase=warning
+org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
+org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
+org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
+org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
+org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
+org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=disabled
+org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
+org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning
+org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=warning
+org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
+org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
+org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=enabled
+org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=enabled
+org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=private
+org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
+org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
+org.eclipse.jdt.core.compiler.problem.missingDefaultCase=ignore
+org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=warning
+org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault=disabled
+org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=warning
+org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
+org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=enabled
+org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=private
+org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=all_standard_tags
+org.eclipse.jdt.core.compiler.problem.missingJavadocTags=ignore
+org.eclipse.jdt.core.compiler.problem.missingJavadocTagsMethodTypeParameters=enabled
+org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
+org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=private
+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=warning
+org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
+org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=warning
+org.eclipse.jdt.core.compiler.problem.nonnullParameterAnnotationDropped=warning
+org.eclipse.jdt.core.compiler.problem.nonnullTypeVariableFromLegacyInvocation=warning
+org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict=error
+org.eclipse.jdt.core.compiler.problem.nullReference=error
+org.eclipse.jdt.core.compiler.problem.nullSpecViolation=error
+org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion=warning
+org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
+org.eclipse.jdt.core.compiler.problem.parameterAssignment=warning
+org.eclipse.jdt.core.compiler.problem.pessimisticNullAnalysisForFreeTypeVariables=warning
+org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=warning
+org.eclipse.jdt.core.compiler.problem.potentialNullReference=warning
+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=warning
+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=ignore
+org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=enabled
+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.syntacticNullAnalysisForFields=disabled
+org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=warning
+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=warning
+org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
+org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
+org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning
+org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=warning
+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.unusedExceptionParameter=ignore
+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=warning
+org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
+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.unusedTypeParameter=warning
+org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
+org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
+org.eclipse.jdt.core.compiler.source=1.8
+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=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
+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=0
+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=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
+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=80
+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=false
+org.eclipse.jdt.core.formatter.indentation.size=2
+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=do not 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=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=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=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=80
+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=space
+org.eclipse.jdt.core.formatter.tabulation.size=2
+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=true
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/.settings/org.eclipse.jdt.ui.prefs b/plugins/org.eclipse.emf.diffmerge.generic/.settings/org.eclipse.jdt.ui.prefs
new file mode 100644
index 0000000..5c8368b
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/.settings/org.eclipse.jdt.ui.prefs
@@ -0,0 +1,9 @@
+eclipse.preferences.version=1
+formatter_profile=_EDMFormatter
+formatter_settings_version=12
+org.eclipse.jdt.ui.exception.name=e
+org.eclipse.jdt.ui.gettersetter.use.is=true
+org.eclipse.jdt.ui.javadoc=false
+org.eclipse.jdt.ui.keywordthis=false
+org.eclipse.jdt.ui.overrideannotation=true
+org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8" standalone\="no"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/**\r\n * @return the ${bare_field_name}\r\n */</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/**\r\n * @param ${param} the ${bare_field_name} to set\r\n */</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/**\r\n * \r\n */</template><template autoinsert\="true" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\r\n * @author ${user}\r\n *\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/**\r\n * \r\n */</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="false" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/**\r\n * ${see_to_overridden}\r\n */</template><template autoinsert\="true" context\="delegatecomment_context" deleted\="false" description\="Comment for delegate methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.delegatecomment" name\="delegatecomment">/**\r\n * ${tags}\r\n * ${see_to_target}\r\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\r\n${package_declaration}\r\n\r\n${typecomment}\r\n${type_declaration}</template><template autoinsert\="true" context\="classbody_context" deleted\="false" description\="Code in new class type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.classbody" name\="classbody">\r\n</template><template autoinsert\="true" context\="interfacebody_context" deleted\="false" description\="Code in new interface type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.interfacebody" name\="interfacebody">\r\n</template><template autoinsert\="true" context\="enumbody_context" deleted\="false" description\="Code in new enum type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.enumbody" name\="enumbody">\r\n</template><template autoinsert\="true" context\="annotationbody_context" deleted\="false" description\="Code in new annotation type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.annotationbody" name\="annotationbody">\r\n</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\r\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\r\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\r\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates>
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/.settings/org.eclipse.pde.prefs b/plugins/org.eclipse.emf.diffmerge.generic/.settings/org.eclipse.pde.prefs
new file mode 100644
index 0000000..093f24d
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/.settings/org.eclipse.pde.prefs
@@ -0,0 +1,32 @@
+compilers.f.unresolved-features=1
+compilers.f.unresolved-plugins=1
+compilers.incompatible-environment=1
+compilers.p.build=1
+compilers.p.build.bin.includes=1
+compilers.p.build.encodings=2
+compilers.p.build.java.compiler=2
+compilers.p.build.java.compliance=1
+compilers.p.build.missing.output=2
+compilers.p.build.output.library=1
+compilers.p.build.source.library=1
+compilers.p.build.src.includes=1
+compilers.p.deprecated=1
+compilers.p.discouraged-class=1
+compilers.p.internal=1
+compilers.p.missing-packages=2
+compilers.p.missing-version-export-package=2
+compilers.p.missing-version-import-package=2
+compilers.p.missing-version-require-bundle=2
+compilers.p.no-required-att=0
+compilers.p.not-externalized-att=1
+compilers.p.unknown-attribute=1
+compilers.p.unknown-class=1
+compilers.p.unknown-element=1
+compilers.p.unknown-identifier=1
+compilers.p.unknown-resource=1
+compilers.p.unresolved-ex-points=0
+compilers.p.unresolved-import=0
+compilers.s.create-docs=false
+compilers.s.doc-folder=doc
+compilers.s.open-tags=1
+eclipse.preferences.version=1
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/META-INF/MANIFEST.MF b/plugins/org.eclipse.emf.diffmerge.generic/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..3eeca05
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/META-INF/MANIFEST.MF
@@ -0,0 +1,28 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %pluginName
+Bundle-SymbolicName: org.eclipse.emf.diffmerge.generic;singleton:=true
+Bundle-Version: 0.12.0.qualifier
+Bundle-ClassPath: .
+Bundle-Vendor: %providerName
+Bundle-Localization: plugin
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.emf.diffmerge.generic,
+ org.eclipse.emf.diffmerge.generic.api,
+ org.eclipse.emf.diffmerge.generic.api.config,
+ org.eclipse.emf.diffmerge.generic.api.diff,
+ org.eclipse.emf.diffmerge.generic.api.scopes,
+ org.eclipse.emf.diffmerge.generic.gdiffdata,
+ org.eclipse.emf.diffmerge.generic.gdiffdata.impl,
+ org.eclipse.emf.diffmerge.generic.gdiffdata.util,
+ org.eclipse.emf.diffmerge.generic.impl.helpers,
+ org.eclipse.emf.diffmerge.generic.impl.policies,
+ org.eclipse.emf.diffmerge.generic.impl.scopes,
+ org.eclipse.emf.diffmerge.generic.util
+Require-Bundle: org.eclipse.emf.diffmerge.structures;visibility:=reexport,
+ org.eclipse.emf.ecore;visibility:=reexport,
+ org.eclipse.equinox.common;visibility:=reexport,
+ org.eclipse.osgi
+Bundle-ActivationPolicy: lazy
+Eclipse-LazyStart: true
+Automatic-Module-Name: org.eclipse.emf.diffmerge.generic
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/about.html b/plugins/org.eclipse.emf.diffmerge.generic/about.html
new file mode 100644
index 0000000..720a1d0
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/about.html
@@ -0,0 +1,25 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>August 17, 2018</p>	
+<h3>License</h3>
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+</body>
+</html>
\ No newline at end of file
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/build.properties b/plugins/org.eclipse.emf.diffmerge.generic/build.properties
new file mode 100644
index 0000000..4465407
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/build.properties
@@ -0,0 +1,10 @@
+#
+
+bin.includes = .,\
+               model/,\
+               META-INF/,\
+               plugin.xml,\
+               plugin.properties
+jars.compile.order = .
+source.. = src/
+output.. = bin/
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/model/GDiffData.ecore b/plugins/org.eclipse.emf.diffmerge.generic/model/GDiffData.ecore
new file mode 100644
index 0000000..7c8bbff
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/model/GDiffData.ecore
@@ -0,0 +1,434 @@
+<?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="gdiffdata" nsURI="http://www.eclipse.org/emf/diffmerge/generic/gdiffdata/1.0.0"
+    nsPrefix="org.eclipse.emf.diffmerge.generic">
+  <eClassifiers xsi:type="ecore:EClass" name="GIdentified" abstract="true">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+        iD="true"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="GComparison" abstract="true">
+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+      <details key="documentation" value="A partial implementation of IComparison based on EMF."/>
+    </eAnnotations>
+    <eTypeParameters name="E"/>
+    <eTypeParameters name="A"/>
+    <eTypeParameters name="R"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="ancestorScope" transient="true">
+      <eGenericType eClassifier="#//IEditableTreeDataScope">
+        <eTypeArguments eTypeParameter="#//GComparison/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="referenceScope" lowerBound="1"
+        transient="true">
+      <eGenericType eClassifier="#//IEditableTreeDataScope">
+        <eTypeArguments eTypeParameter="#//GComparison/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="targetScope" lowerBound="1"
+        transient="true">
+      <eGenericType eClassifier="#//IEditableTreeDataScope">
+        <eTypeArguments eTypeParameter="#//GComparison/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="lastMatchPolicy" transient="true">
+      <eGenericType eClassifier="#//IMatchPolicy">
+        <eTypeArguments eTypeParameter="#//GComparison/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="lastDiffPolicy" transient="true">
+      <eGenericType eClassifier="#//IDiffPolicy">
+        <eTypeArguments eTypeParameter="#//GComparison/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="lastMergePolicy" transient="true">
+      <eGenericType eClassifier="#//IMergePolicy">
+        <eTypeArguments eTypeParameter="#//GComparison/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="mapping" lowerBound="1"
+        containment="true">
+      <eGenericType eClassifier="#//GMapping">
+        <eTypeArguments eTypeParameter="#//GComparison/E"/>
+        <eTypeArguments eTypeParameter="#//GComparison/A"/>
+        <eTypeArguments eTypeParameter="#//GComparison/R"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eGenericSuperTypes eClassifier="#//GIdentified"/>
+    <eGenericSuperTypes eClassifier="#//IEditableComparison">
+      <eTypeArguments eTypeParameter="#//GComparison/E"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="GComparisonElement" abstract="true"
+      interface="true">
+    <eTypeParameters name="E"/>
+    <eTypeParameters name="A"/>
+    <eTypeParameters name="R"/>
+    <eOperations name="getComparison">
+      <eGenericType eClassifier="#//GComparison">
+        <eTypeArguments eTypeParameter="#//GComparisonElement/E"/>
+        <eTypeArguments eTypeParameter="#//GComparisonElement/A"/>
+        <eTypeArguments eTypeParameter="#//GComparisonElement/R"/>
+      </eGenericType>
+    </eOperations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="GMapping" abstract="true">
+    <eTypeParameters name="E"/>
+    <eTypeParameters name="A"/>
+    <eTypeParameters name="R"/>
+    <eOperations name="disconnect" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
+      <eParameters name="role" lowerBound="1" eType="#//Role"/>
+      <eParameters name="element" lowerBound="1">
+        <eGenericType eTypeParameter="#//GMapping/E"/>
+      </eParameters>
+    </eOperations>
+    <eOperations name="isIgnoredReferenceValue" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
+      <eParameters name="source" lowerBound="1">
+        <eGenericType eTypeParameter="#//GMapping/E"/>
+      </eParameters>
+      <eParameters name="reference" lowerBound="1">
+        <eGenericType eTypeParameter="#//GMapping/R"/>
+      </eParameters>
+      <eParameters name="value" lowerBound="1">
+        <eGenericType eTypeParameter="#//GMapping/E"/>
+      </eParameters>
+      <eParameters name="role" lowerBound="1" eType="#//Role"/>
+    </eOperations>
+    <eOperations name="map" lowerBound="1">
+      <eGenericType eClassifier="#//GMatch">
+        <eTypeArguments eTypeParameter="#//GMapping/E"/>
+        <eTypeArguments eTypeParameter="#//GMapping/A"/>
+        <eTypeArguments eTypeParameter="#//GMapping/R"/>
+      </eGenericType>
+      <eParameters name="element" lowerBound="1">
+        <eGenericType eTypeParameter="#//GMapping/E"/>
+      </eParameters>
+      <eParameters name="role" lowerBound="1" eType="#//Role"/>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="modifiableContents" upperBound="-1"
+        containment="true">
+      <eGenericType eClassifier="#//GMatch">
+        <eTypeArguments eTypeParameter="#//GMapping/E"/>
+        <eTypeArguments eTypeParameter="#//GMapping/A"/>
+        <eTypeArguments eTypeParameter="#//GMapping/R"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="referenceCompletedMatches"
+        upperBound="-1" resolveProxies="false">
+      <eGenericType eClassifier="#//IMatch">
+        <eTypeArguments eTypeParameter="#//GMapping/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="targetCompletedMatches"
+        upperBound="-1" resolveProxies="false">
+      <eGenericType eClassifier="#//IMatch">
+        <eTypeArguments eTypeParameter="#//GMapping/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eGenericSuperTypes eClassifier="#//GIdentified"/>
+    <eGenericSuperTypes eClassifier="#//GComparisonElement">
+      <eTypeArguments eTypeParameter="#//GMapping/E"/>
+      <eTypeArguments eTypeParameter="#//GMapping/A"/>
+      <eTypeArguments eTypeParameter="#//GMapping/R"/>
+    </eGenericSuperTypes>
+    <eGenericSuperTypes eClassifier="#//IEditableMapping">
+      <eTypeArguments eTypeParameter="#//GMapping/E"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="GMatch" abstract="true">
+    <eTypeParameters name="E"/>
+    <eTypeParameters name="A"/>
+    <eTypeParameters name="R"/>
+    <eOperations name="getAncestor">
+      <eGenericType eTypeParameter="#//GMatch/E"/>
+    </eOperations>
+    <eOperations name="getReference">
+      <eGenericType eTypeParameter="#//GMatch/E"/>
+    </eOperations>
+    <eOperations name="getTarget">
+      <eGenericType eTypeParameter="#//GMatch/E"/>
+    </eOperations>
+    <eOperations name="setAncestor">
+      <eParameters name="e">
+        <eGenericType eTypeParameter="#//GMatch/E"/>
+      </eParameters>
+    </eOperations>
+    <eOperations name="setReference">
+      <eParameters name="e">
+        <eGenericType eTypeParameter="#//GMatch/E"/>
+      </eParameters>
+    </eOperations>
+    <eOperations name="setTarget">
+      <eParameters name="e">
+        <eGenericType eTypeParameter="#//GMatch/E"/>
+      </eParameters>
+    </eOperations>
+    <eOperations name="getMapping" lowerBound="1">
+      <eGenericType eClassifier="#//GMapping">
+        <eTypeArguments eTypeParameter="#//GMatch/E"/>
+        <eTypeArguments eTypeParameter="#//GMatch/A"/>
+        <eTypeArguments eTypeParameter="#//GMatch/R"/>
+      </eGenericType>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="matchID" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
+        transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="modifiableRelatedDifferences"
+        upperBound="-1" containment="true">
+      <eGenericType eClassifier="#//GMergeableDifference">
+        <eTypeArguments eTypeParameter="#//GMatch/E"/>
+        <eTypeArguments eTypeParameter="#//GMatch/A"/>
+        <eTypeArguments eTypeParameter="#//GMatch/R"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="elementPresenceDifference">
+      <eGenericType eClassifier="#//IElementPresence">
+        <eTypeArguments eTypeParameter="#//GMatch/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="referenceOwnershipDifference">
+      <eGenericType eClassifier="#//IReferenceValuePresence">
+        <eTypeArguments eTypeParameter="#//GMatch/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="targetOwnershipDifference">
+      <eGenericType eClassifier="#//IReferenceValuePresence">
+        <eTypeArguments eTypeParameter="#//GMatch/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eGenericSuperTypes eClassifier="#//GIdentified"/>
+    <eGenericSuperTypes eClassifier="#//GComparisonElement">
+      <eTypeArguments eTypeParameter="#//GMatch/E"/>
+      <eTypeArguments eTypeParameter="#//GMatch/A"/>
+      <eTypeArguments eTypeParameter="#//GMatch/R"/>
+    </eGenericSuperTypes>
+    <eGenericSuperTypes eClassifier="#//IEditableMatch">
+      <eTypeArguments eTypeParameter="#//GMatch/E"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="GMergeableDifference" abstract="true">
+    <eTypeParameters name="E"/>
+    <eTypeParameters name="A"/>
+    <eTypeParameters name="R"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="alignedWithAncestor" lowerBound="1"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean" defaultValueLiteral="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="conflicting" lowerBound="1"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean" defaultValueLiteral="false"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="ignored" lowerBound="1"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="mergeDestination" eType="#//Role"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="possibleMergeDestinations"
+        upperBound="-1" eType="#//Role"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="explicitDependenciesForTarget"
+        upperBound="-1">
+      <eGenericType eClassifier="#//IMergeableDifference">
+        <eTypeArguments eTypeParameter="#//GMergeableDifference/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="explicitDependenciesForReference"
+        upperBound="-1">
+      <eGenericType eClassifier="#//IMergeableDifference">
+        <eTypeArguments eTypeParameter="#//GMergeableDifference/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="implicitDependenciesForTarget"
+        upperBound="-1">
+      <eGenericType eClassifier="#//IMergeableDifference">
+        <eTypeArguments eTypeParameter="#//GMergeableDifference/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="implicitDependenciesForReference"
+        upperBound="-1">
+      <eGenericType eClassifier="#//IMergeableDifference">
+        <eTypeArguments eTypeParameter="#//GMergeableDifference/E"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eGenericSuperTypes eClassifier="#//GIdentified"/>
+    <eGenericSuperTypes eClassifier="#//GComparisonElement">
+      <eTypeArguments eTypeParameter="#//GMergeableDifference/E"/>
+      <eTypeArguments eTypeParameter="#//GMergeableDifference/A"/>
+      <eTypeArguments eTypeParameter="#//GMergeableDifference/R"/>
+    </eGenericSuperTypes>
+    <eGenericSuperTypes eClassifier="#//IEditableMergeableDifference">
+      <eTypeArguments eTypeParameter="#//GMergeableDifference/E"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="GElementRelativePresence" abstract="true">
+    <eTypeParameters name="E"/>
+    <eTypeParameters name="A"/>
+    <eTypeParameters name="R"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="elementMatch" lowerBound="1">
+      <eGenericType eClassifier="#//GMatch">
+        <eTypeArguments eTypeParameter="#//GElementRelativePresence/E"/>
+        <eTypeArguments eTypeParameter="#//GElementRelativePresence/A"/>
+        <eTypeArguments eTypeParameter="#//GElementRelativePresence/R"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="presenceRole" lowerBound="1"
+        eType="#//Role"/>
+    <eGenericSuperTypes eClassifier="#//GMergeableDifference">
+      <eTypeArguments eTypeParameter="#//GElementRelativePresence/E"/>
+      <eTypeArguments eTypeParameter="#//GElementRelativePresence/A"/>
+      <eTypeArguments eTypeParameter="#//GElementRelativePresence/R"/>
+    </eGenericSuperTypes>
+    <eGenericSuperTypes eClassifier="#//IElementRelativePresence">
+      <eTypeArguments eTypeParameter="#//GElementRelativePresence/E"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="GElementPresence" abstract="true">
+    <eTypeParameters name="E"/>
+    <eTypeParameters name="A"/>
+    <eTypeParameters name="R"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="ownerMatch" lowerBound="1">
+      <eGenericType eClassifier="#//GMatch">
+        <eTypeArguments eTypeParameter="#//GElementPresence/E"/>
+        <eTypeArguments eTypeParameter="#//GElementPresence/A"/>
+        <eTypeArguments eTypeParameter="#//GElementPresence/R"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eGenericSuperTypes eClassifier="#//GElementRelativePresence">
+      <eTypeArguments eTypeParameter="#//GElementPresence/E"/>
+      <eTypeArguments eTypeParameter="#//GElementPresence/A"/>
+      <eTypeArguments eTypeParameter="#//GElementPresence/R"/>
+    </eGenericSuperTypes>
+    <eGenericSuperTypes eClassifier="#//IElementPresence">
+      <eTypeArguments eTypeParameter="#//GElementPresence/E"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="GValuePresence" abstract="true">
+    <eTypeParameters name="E"/>
+    <eTypeParameters name="A"/>
+    <eTypeParameters name="R"/>
+    <eOperations name="getFeature" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="order" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
+        defaultValueLiteral="false"/>
+    <eGenericSuperTypes eClassifier="#//GElementRelativePresence">
+      <eTypeArguments eTypeParameter="#//GValuePresence/E"/>
+      <eTypeArguments eTypeParameter="#//GValuePresence/A"/>
+      <eTypeArguments eTypeParameter="#//GValuePresence/R"/>
+    </eGenericSuperTypes>
+    <eGenericSuperTypes eClassifier="#//IValuePresence">
+      <eTypeArguments eTypeParameter="#//GValuePresence/E"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="GAttributeValuePresence" abstract="true">
+    <eTypeParameters name="E"/>
+    <eTypeParameters name="A"/>
+    <eTypeParameters name="R"/>
+    <eOperations name="getFeature" lowerBound="1">
+      <eGenericType eTypeParameter="#//GAttributeValuePresence/A"/>
+    </eOperations>
+    <eOperations name="setAttribute">
+      <eParameters name="attribute" lowerBound="1">
+        <eGenericType eTypeParameter="#//GAttributeValuePresence/A"/>
+      </eParameters>
+    </eOperations>
+    <eOperations name="setValue">
+      <eParameters name="value" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"/>
+    </eOperations>
+    <eGenericSuperTypes eClassifier="#//GValuePresence">
+      <eTypeArguments eTypeParameter="#//GAttributeValuePresence/E"/>
+      <eTypeArguments eTypeParameter="#//GAttributeValuePresence/A"/>
+      <eTypeArguments eTypeParameter="#//GAttributeValuePresence/R"/>
+    </eGenericSuperTypes>
+    <eGenericSuperTypes eClassifier="#//IAttributeValuePresence">
+      <eTypeArguments eTypeParameter="#//GAttributeValuePresence/E"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="GReferenceValuePresence" abstract="true">
+    <eTypeParameters name="E"/>
+    <eTypeParameters name="A"/>
+    <eTypeParameters name="R"/>
+    <eOperations name="getFeature" lowerBound="1">
+      <eGenericType eTypeParameter="#//GReferenceValuePresence/R"/>
+    </eOperations>
+    <eOperations name="setReference">
+      <eParameters name="reference" lowerBound="1">
+        <eGenericType eTypeParameter="#//GReferenceValuePresence/R"/>
+      </eParameters>
+    </eOperations>
+    <eOperations name="setValue">
+      <eParameters name="value" lowerBound="1">
+        <eGenericType eTypeParameter="#//GReferenceValuePresence/E"/>
+      </eParameters>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="valueMatch">
+      <eGenericType eClassifier="#//GMatch">
+        <eTypeArguments eTypeParameter="#//GReferenceValuePresence/E"/>
+        <eTypeArguments eTypeParameter="#//GReferenceValuePresence/A"/>
+        <eTypeArguments eTypeParameter="#//GReferenceValuePresence/R"/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eGenericSuperTypes eClassifier="#//GValuePresence">
+      <eTypeArguments eTypeParameter="#//GReferenceValuePresence/E"/>
+      <eTypeArguments eTypeParameter="#//GReferenceValuePresence/A"/>
+      <eTypeArguments eTypeParameter="#//GReferenceValuePresence/R"/>
+    </eGenericSuperTypes>
+    <eGenericSuperTypes eClassifier="#//IReferenceValuePresence">
+      <eTypeArguments eTypeParameter="#//GReferenceValuePresence/E"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IComparison" instanceClassName="org.eclipse.emf.diffmerge.generic.api.IComparison"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IEditableComparison" instanceClassName="org.eclipse.emf.diffmerge.generic.api.IComparison.Editable"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IMapping" instanceClassName="org.eclipse.emf.diffmerge.generic.api.IMapping"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IEditableMapping" instanceClassName="org.eclipse.emf.diffmerge.generic.api.IMapping.Editable"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IMatch" instanceClassName="org.eclipse.emf.diffmerge.generic.api.IMatch"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IEditableMatch" instanceClassName="org.eclipse.emf.diffmerge.generic.api.IMatch.Editable"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IMergeableDifference" instanceClassName="org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IEditableMergeableDifference" instanceClassName="org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IElementRelativePresence" instanceClassName="org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativePresence"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IElementPresence" instanceClassName="org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IValuePresence" instanceClassName="org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IAttributeValuePresence" instanceClassName="org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IReferenceValuePresence" instanceClassName="org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence"
+      abstract="true" interface="true">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="IEditableTreeDataScope" instanceClassName="org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="IMatchPolicy" instanceClassName="org.eclipse.emf.diffmerge.generic.api.IMatchPolicy">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="IDiffPolicy" instanceClassName="org.eclipse.emf.diffmerge.generic.api.IDiffPolicy">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="IMergePolicy" instanceClassName="org.eclipse.emf.diffmerge.generic.api.IMergePolicy">
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="Role" instanceClassName="org.eclipse.emf.diffmerge.generic.api.Role"/>
+</ecore:EPackage>
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/model/GDiffData.genmodel b/plugins/org.eclipse.emf.diffmerge.generic/model/GDiffData.genmodel
new file mode 100644
index 0000000..1271e44
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/model/GDiffData.genmodel
@@ -0,0 +1,191 @@
+<?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" modelDirectory="/org.eclipse.emf.diffmerge.generic/src" modelPluginID="org.eclipse.emf.diffmerge.generic"
+    modelName="GDiffData" editPluginClass="org.eclipse.emf.diffmerge.generic.gdiffdata.provider.GenericDiffDataEditPlugin"
+    editorPluginClass="org.eclipse.emf.diffmerge.generic.gdiffdata.presentation.GenericDiffDataEditorPlugin"
+    nonNLSMarkers="true" codeFormatting="true" testSuiteClass="org.eclipse.emf.diffmerge.generic.gdiffdata.tests.GenericDiffDataAllTests"
+    importerID="org.eclipse.emf.importer.ecore" bundleManifest="false" suppressUnsettable="true"
+    complianceLevel="5.0" copyrightFields="false" runtimeVersion="2.6" usedGenPackages="platform:/plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore"
+    importOrganizing="true">
+  <foreignModel>GDiffData.ecore</foreignModel>
+  <genPackages prefix="Gdiffdata" basePackage="org.eclipse.emf.diffmerge.generic"
+      disposableProviderFactory="true" fileExtensions="gdiffdata" ecorePackage="GDiffData.ecore#/">
+    <genDataTypes ecoreDataType="GDiffData.ecore#//IEditableTreeDataScope">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IEditableTreeDataScope/E"/>
+    </genDataTypes>
+    <genDataTypes ecoreDataType="GDiffData.ecore#//IMatchPolicy">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IMatchPolicy/E"/>
+    </genDataTypes>
+    <genDataTypes ecoreDataType="GDiffData.ecore#//IDiffPolicy">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IDiffPolicy/E"/>
+    </genDataTypes>
+    <genDataTypes ecoreDataType="GDiffData.ecore#//IMergePolicy">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IMergePolicy/E"/>
+    </genDataTypes>
+    <genDataTypes ecoreDataType="GDiffData.ecore#//Role"/>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//GIdentified">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GIdentified/id"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//GComparison">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GComparison/E"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GComparison/A"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GComparison/R"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GComparison/ancestorScope"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GComparison/referenceScope"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GComparison/targetScope"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GComparison/lastMatchPolicy"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GComparison/lastDiffPolicy"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GComparison/lastMergePolicy"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GComparison/mapping"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//GComparisonElement">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GComparisonElement/E"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GComparisonElement/A"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GComparisonElement/R"/>
+      <genOperations ecoreOperation="GDiffData.ecore#//GComparisonElement/getComparison"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//GMapping">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GMapping/E"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GMapping/A"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GMapping/R"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GMapping/modifiableContents"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GMapping/referenceCompletedMatches"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GMapping/targetCompletedMatches"/>
+      <genOperations ecoreOperation="GDiffData.ecore#//GMapping/disconnect">
+        <genParameters ecoreParameter="GDiffData.ecore#//GMapping/disconnect/role"/>
+        <genParameters ecoreParameter="GDiffData.ecore#//GMapping/disconnect/element"/>
+      </genOperations>
+      <genOperations ecoreOperation="GDiffData.ecore#//GMapping/isIgnoredReferenceValue">
+        <genParameters ecoreParameter="GDiffData.ecore#//GMapping/isIgnoredReferenceValue/source"/>
+        <genParameters ecoreParameter="GDiffData.ecore#//GMapping/isIgnoredReferenceValue/reference"/>
+        <genParameters ecoreParameter="GDiffData.ecore#//GMapping/isIgnoredReferenceValue/value"/>
+        <genParameters ecoreParameter="GDiffData.ecore#//GMapping/isIgnoredReferenceValue/role"/>
+      </genOperations>
+      <genOperations ecoreOperation="GDiffData.ecore#//GMapping/map">
+        <genParameters ecoreParameter="GDiffData.ecore#//GMapping/map/element"/>
+        <genParameters ecoreParameter="GDiffData.ecore#//GMapping/map/role"/>
+      </genOperations>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//GMatch">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GMatch/E"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GMatch/A"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GMatch/R"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GMatch/matchID"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GMatch/modifiableRelatedDifferences"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GMatch/elementPresenceDifference"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GMatch/referenceOwnershipDifference"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GMatch/targetOwnershipDifference"/>
+      <genOperations ecoreOperation="GDiffData.ecore#//GMatch/getAncestor"/>
+      <genOperations ecoreOperation="GDiffData.ecore#//GMatch/getReference"/>
+      <genOperations ecoreOperation="GDiffData.ecore#//GMatch/getTarget"/>
+      <genOperations ecoreOperation="GDiffData.ecore#//GMatch/setAncestor">
+        <genParameters ecoreParameter="GDiffData.ecore#//GMatch/setAncestor/e"/>
+      </genOperations>
+      <genOperations ecoreOperation="GDiffData.ecore#//GMatch/setReference">
+        <genParameters ecoreParameter="GDiffData.ecore#//GMatch/setReference/e"/>
+      </genOperations>
+      <genOperations ecoreOperation="GDiffData.ecore#//GMatch/setTarget">
+        <genParameters ecoreParameter="GDiffData.ecore#//GMatch/setTarget/e"/>
+      </genOperations>
+      <genOperations ecoreOperation="GDiffData.ecore#//GMatch/getMapping"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//GMergeableDifference">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GMergeableDifference/E"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GMergeableDifference/A"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GMergeableDifference/R"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GMergeableDifference/alignedWithAncestor"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GMergeableDifference/conflicting"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GMergeableDifference/ignored"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GMergeableDifference/mergeDestination"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GMergeableDifference/possibleMergeDestinations"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GMergeableDifference/explicitDependenciesForTarget"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GMergeableDifference/explicitDependenciesForReference"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GMergeableDifference/implicitDependenciesForTarget"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GMergeableDifference/implicitDependenciesForReference"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//GElementRelativePresence">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GElementRelativePresence/E"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GElementRelativePresence/A"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GElementRelativePresence/R"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GElementRelativePresence/elementMatch"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GElementRelativePresence/presenceRole"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//GElementPresence">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GElementPresence/E"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GElementPresence/A"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GElementPresence/R"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GElementPresence/ownerMatch"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//GValuePresence">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GValuePresence/E"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GValuePresence/A"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GValuePresence/R"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute GDiffData.ecore#//GValuePresence/order"/>
+      <genOperations ecoreOperation="GDiffData.ecore#//GValuePresence/getFeature"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//GAttributeValuePresence">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GAttributeValuePresence/E"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GAttributeValuePresence/A"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GAttributeValuePresence/R"/>
+      <genOperations ecoreOperation="GDiffData.ecore#//GAttributeValuePresence/getFeature"/>
+      <genOperations ecoreOperation="GDiffData.ecore#//GAttributeValuePresence/setAttribute">
+        <genParameters ecoreParameter="GDiffData.ecore#//GAttributeValuePresence/setAttribute/attribute"/>
+      </genOperations>
+      <genOperations ecoreOperation="GDiffData.ecore#//GAttributeValuePresence/setValue">
+        <genParameters ecoreParameter="GDiffData.ecore#//GAttributeValuePresence/setValue/value"/>
+      </genOperations>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//GReferenceValuePresence">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GReferenceValuePresence/E"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GReferenceValuePresence/A"/>
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//GReferenceValuePresence/R"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference GDiffData.ecore#//GReferenceValuePresence/valueMatch"/>
+      <genOperations ecoreOperation="GDiffData.ecore#//GReferenceValuePresence/getFeature"/>
+      <genOperations ecoreOperation="GDiffData.ecore#//GReferenceValuePresence/setReference">
+        <genParameters ecoreParameter="GDiffData.ecore#//GReferenceValuePresence/setReference/reference"/>
+      </genOperations>
+      <genOperations ecoreOperation="GDiffData.ecore#//GReferenceValuePresence/setValue">
+        <genParameters ecoreParameter="GDiffData.ecore#//GReferenceValuePresence/setValue/value"/>
+      </genOperations>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IComparison">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IComparison/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IEditableComparison">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IEditableComparison/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IMapping">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IMapping/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IEditableMapping">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IEditableMapping/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IMatch">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IMatch/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IEditableMatch">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IEditableMatch/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IMergeableDifference">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IMergeableDifference/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IEditableMergeableDifference">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IEditableMergeableDifference/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IElementRelativePresence">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IElementRelativePresence/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IElementPresence">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IElementPresence/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IValuePresence">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IValuePresence/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IAttributeValuePresence">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IAttributeValuePresence/E"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="GDiffData.ecore#//IReferenceValuePresence">
+      <genTypeParameters ecoreTypeParameter="GDiffData.ecore#//IReferenceValuePresence/E"/>
+    </genClasses>
+  </genPackages>
+</genmodel:GenModel>
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/plugin.properties b/plugins/org.eclipse.emf.diffmerge.generic/plugin.properties
new file mode 100644
index 0000000..97f564e
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/plugin.properties
@@ -0,0 +1,10 @@
+###############################################################################
+# Copyright (c) 2010-2019 Thales Global Services S.A.S.
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
+###############################################################################
+pluginName = EMF Diff/Merge Generic Plug-In (Incubation)
+providerName = Eclipse Modeling Project
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/plugin.xml b/plugins/org.eclipse.emf.diffmerge.generic/plugin.xml
new file mode 100644
index 0000000..26cacda
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/plugin.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<!--
+  Copyright (c) 2019 Thales Global Services S.A.S.
+  This program and the accompanying materials are made
+  available under the terms of the Eclipse Public License 2.0
+  which is available at https://www.eclipse.org/legal/epl-2.0/
+  
+  SPDX-License-Identifier: EPL-2.0
+  
+   Contributors:
+  Thales Global Services S.A.S - initial API and implementation
+-->
+
+<plugin>
+
+   <extension point="org.eclipse.emf.ecore.generated_package">
+      <!-- @generated GDiffData -->
+      <package
+            uri="http://www.eclipse.org/emf/diffmerge/generic/gdiffdata/1.0.0"
+            class="org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage"
+            genModel="model/GDiffData.genmodel"/>
+   </extension>
+
+</plugin>
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/Messages.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/Messages.java
new file mode 100644
index 0000000..e730d65
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/Messages.java
@@ -0,0 +1,40 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic;
+
+import org.eclipse.osgi.util.NLS;
+
+
+/**
+ * Utility class for the externalization mechanism.
+ * @author Olivier Constant
+ */
+@SuppressWarnings("javadoc")
+public class Messages extends NLS {
+  private static final String BUNDLE_NAME = "org.eclipse.emf.diffmerge.generic.messages"; //$NON-NLS-1$
+  public static String AbstractDifference_UnableToMerge;
+  public static String DiffBuilder_Task_Main;
+  public static String Comparison_Task_Main;
+  public static String MatchBuilder_Task_Main;
+  public static String MatchBuilder_Task_MappingIDs;
+  public static String MatchBuilder_Task_RegisteringIDs;
+  public static String MergeOperation_Name;
+  static {
+    // initialize resource bundle
+    NLS.initializeMessages(BUNDLE_NAME, Messages.class);
+  }
+
+  private Messages() {
+    // Nothing
+  }
+  
+}
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IComparison.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IComparison.java
similarity index 76%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IComparison.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IComparison.java
index 205d3d3..f423fe2 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IComparison.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IComparison.java
@@ -9,7 +9,7 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api;
+package org.eclipse.emf.diffmerge.generic.api;
 
 import java.util.Collection;
 import java.util.List;
@@ -17,34 +17,35 @@
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.emf.common.util.TreeIterator;
-import org.eclipse.emf.diffmerge.api.diff.IAttributeValuePresence;
-import org.eclipse.emf.diffmerge.api.diff.IDifference;
-import org.eclipse.emf.diffmerge.api.diff.IElementPresence;
-import org.eclipse.emf.diffmerge.api.diff.IReferenceValuePresence;
-import org.eclipse.emf.diffmerge.api.scopes.IEditableModelScope;
-import org.eclipse.emf.diffmerge.api.scopes.IFeaturedModelScope;
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence;
+import org.eclipse.emf.diffmerge.generic.api.diff.IDifference;
+import org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence;
+import org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IDataScope;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope;
+import org.eclipse.emf.diffmerge.generic.api.scopes.ITreeDataScope;
 
 
 /**
- * A comparison between model scopes.
+ * A comparison between data scopes.
  * A comparison, once defined, can be computed using match, diff and merge policies.
  * After computation, it provides a mapping between the contents of the scopes,
  * a set of differences based on this mapping and the ability to merge a subset of
  * those differences according to the merge policy.
  * If the match policy provided was not suitable to the scopes, then the computed
  * comparison is not consistent and merge is discouraged.
- * @see IFeaturedModelScope
+ * @see IDataScope
  * @see IMatchPolicy
  * @see IDiffPolicy
  * @see IMergePolicy
  * @see IDifference
  * @see IComparison#isConsistent()
+ *
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IComparison {
+public interface IComparison<E> {
   
   /**
    * Clear this comparison, going back to its state before compute(...) was called
@@ -60,8 +61,8 @@
    * @param monitor_p an optional progress monitor
    * @return a non-null status of the execution
    */
-  IStatus compute(IMatchPolicy matchPolicy_p, IDiffPolicy diffPolicy_p,
-      IMergePolicy mergePolicy_p, IProgressMonitor monitor_p);
+  IStatus compute(IMatchPolicy<E> matchPolicy_p, IDiffPolicy<E> diffPolicy_p,
+      IMergePolicy<E> mergePolicy_p, IProgressMonitor monitor_p);
   
   /**
    * Return a tree iterator over matches based on getContentsOf(IMatch, Role)
@@ -69,7 +70,7 @@
    * @param role_p a non-null role
    * @return a non-null iterator
    */
-  TreeIterator<IMatch> getAllContents(Role role_p);
+  TreeIterator<IMatch<E>> getAllContents(Role role_p);
   
   /**
    * Return the match for the container of the given match in the given role.
@@ -79,20 +80,20 @@
    * @param role_p a non-null role
    * @return a potentially null match
    */
-  IMatch getContainerOf(IMatch match_p, Role role_p);
+  IMatch<E> getContainerOf(IMatch<E> match_p, Role role_p);
   
   /**
    * Return the matches for the roots of the TARGET and REFERENCE scopes
    * @return a non-null, potentially empty, unmodifiable ordered set of matches
    */
-  List<IMatch> getContents();
+  List<IMatch<E>> getContents();
   
   /**
    * Return the matches for the roots of the scope of the given role
    * @param role_p a non-null role
    * @return a non-null, potentially empty, unmodifiable ordered set of matches
    */
-  List<IMatch> getContents(Role role_p);
+  List<IMatch<E>> getContents(Role role_p);
   
   /**
    * Return the matches for the contents of the given match in the TARGET and
@@ -100,7 +101,7 @@
    * @param match_p a non-null match
    * @return a non-null, potentially empty, unmodifiable ordered set of matches
    */
-  List<IMatch> getContentsOf(IMatch match_p);
+  List<IMatch<E>> getContentsOf(IMatch<E> match_p);
   
   /**
    * Return the matches for the contents of the given match in the given role
@@ -108,7 +109,7 @@
    * @param role_p a non-null role
    * @return a non-null, potentially empty, unmodifiable ordered set of matches
    */
-  List<IMatch> getContentsOf(IMatch match_p, Role role_p);
+  List<IMatch<E>> getContentsOf(IMatch<E> match_p, Role role_p);
   
   /**
    * Return all differences in the given role.
@@ -118,7 +119,7 @@
    * @return a non-null, unmodifiable list which may contain duplicates if differences
    *         are not low-level, technical differences
    */
-  List<IDifference> getDifferences(Role role_p);
+  List<IDifference<E>> getDifferences(Role role_p);
   
   /**
    * Return the set of duplicate match IDs for the given role, if any.
@@ -134,25 +135,25 @@
    * Return the last diff policy used by this comparison
    * @return a possibly null diff policy (non-null if the last compute(...) succeeded)
    */
-  IDiffPolicy getLastDiffPolicy();
+  IDiffPolicy<E> getLastDiffPolicy();
   
   /**
    * Return the last match policy used by this comparison
    * @return a possibly null match policy (non-null if the last compute(...) succeeded)
    */
-  IMatchPolicy getLastMatchPolicy();
+  IMatchPolicy<E> getLastMatchPolicy();
   
   /**
    * Return the last merge policy used by this comparison
    * @return a possibly null merge policy (non-null if the last compute(...) succeeded)
    */
-  IMergePolicy getLastMergePolicy();
+  IMergePolicy<E> getLastMergePolicy();
   
   /**
    * Return the mapping between the model scopes of this comparison
    * @return a non-null mapping
    */
-  IMapping getMapping();
+  IMapping<E> getMapping();
   
   /**
    * Return the number of differences as the sum of the number of differences
@@ -172,14 +173,14 @@
    * The resulting collection may become obsolete if the comparison is reset.
    * @return a non-null, potentially empty, unmodifiable collection
    */
-  Collection<IDifference> getRemainingDifferences();
+  Collection<IDifference<E>> getRemainingDifferences();
   
   /**
    * Return the scope for the given role
    * @param role_p a non-null role
    * @return a scope which is non-null iff the given role is covered by this comparison
    */
-  IFeaturedModelScope getScope(Role role_p);
+  ITreeDataScope<E> getScope(Role role_p);
   
   /**
    * Return whether there are differences which have not been merged.
@@ -211,8 +212,8 @@
    * @return a non-null, potentially empty, unmodifiable set of the differences
    *         which have actually been merged
    */
-  Collection<IDifference> merge(Role destination_p, boolean updateReferences_p,
-      IProgressMonitor monitor_p);
+  Collection<IDifference<E>> merge(Role destination_p,
+      boolean updateReferences_p, IProgressMonitor monitor_p);
   
   /**
    * Merge the given set of differences to the given destination role
@@ -223,7 +224,8 @@
    * @return a non-null, potentially empty, unmodifiable set of the differences
    *         which have actually been merged
    */
-  Collection<IDifference> merge(Collection<? extends IDifference> differences_p, Role destination_p,
+  Collection<IDifference<E>> merge(
+      Collection<? extends IDifference<E>> differences_p, Role destination_p,
       boolean updateReferences_p, IProgressMonitor monitor_p);
   
   /**
@@ -235,45 +237,47 @@
    * @return a non-null, potentially empty, unmodifiable set of the differences
    *         which have actually been merged
    */
-  Collection<IDifference> merge(IMergeSelector merger_p, boolean updateReferences_p,
-      IProgressMonitor monitor_p);
+  Collection<IDifference<E>> merge(IMergeSelector<E> merger_p,
+      boolean updateReferences_p, IProgressMonitor monitor_p);
   
   
   /**
    * A comparison with editing features.
    * All concrete classes implementing IComparison must also implement this interface.
    */
-  interface Editable extends IComparison {
+  interface Editable<E> extends IComparison<E> {
     /**
-     * @see org.eclipse.emf.diffmerge.api.IComparison#getMapping()
+     * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getMapping()
      */
-    IMapping.Editable getMapping();
+    IMapping.Editable<E> getMapping();
     
     /**
-     * @see org.eclipse.emf.diffmerge.api.IComparison#getScope(org.eclipse.emf.diffmerge.api.Role)
+     * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getScope(org.eclipse.emf.diffmerge.generic.api.Role)
      */
-    IEditableModelScope getScope(Role role_p);
+    IEditableTreeDataScope<E> getScope(Role role_p);
     
     /**
      * Create and return an attribute value presence with the given characteristics
      * @param elementMatch_p the non-null match for the element holding the value
      * @param attribute_p the non-null attribute holding the value
      * @param value_p the non-null value held
-     * @param presenceRole_p the role in which the value is held: TARGET or REFERENCE
+     * @param presenceRole_p the non-null role in which the value is held: TARGET or REFERENCE
      * @param isOrder_p whether the value presence is solely due to ordering
      * @return a non-null attribute value presence
      */
-    IAttributeValuePresence newAttributeValuePresence(
-        IMatch elementMatch_p, EAttribute attribute_p, Object value_p,
+    IAttributeValuePresence<E> newAttributeValuePresence(
+        IMatch<E> elementMatch_p, Object attribute_p, Object value_p,
         Role presenceRole_p, boolean isOrder_p);
     
     /**
-     * Create and return a reference value presence with the given characteristics
+     * Create and return an element presence with the given characteristics
      * @param elementMatch_p the non-null partial match for the element presence
      * @param ownerMatch_p a potentially null match for the owner of the element
+     * @param presenceRole_p the non-null role in which the element is present: TARGET or REFERENCE
      * @return a non-null element presence
      */
-    IElementPresence newElementPresence(IMatch elementMatch_p, IMatch ownerMatch_p);
+    IElementPresence<E> newElementPresence(IMatch<E> elementMatch_p,
+        IMatch<E> ownerMatch_p, Role presenceRole_p);
     
     /**
      * Create and return a match with the given characteristics
@@ -282,8 +286,8 @@
      * @param ancestorElement_p an optional element on the ANCESTOR side
      * @return a non-null match
      */
-    IMatch newMatch(EObject targetElement_p, EObject referenceElement_p,
-        EObject ancestorElement_p);
+    IMatch<E> newMatch(E targetElement_p, E referenceElement_p,
+        E ancestorElement_p);
     
     /**
      * Create and return a reference value presence with the given characteristics
@@ -291,13 +295,13 @@
      * @param reference_p the non-null reference holding the value
      * @param value_p the value element, which may only be null if valueMatch_p is not null
      * @param valueMatch_p an optional match, which cannot be null if value_p or reference_p is null
-     * @param presenceRole_p the role in which the value is held: TARGET or REFERENCE
+     * @param presenceRole_p the non-null role in which the value is held: TARGET or REFERENCE
      * @param isOrder_p whether the value presence is solely due to ordering
      * @return a non-null reference value presence
      */
-    IReferenceValuePresence newReferenceValuePresence(
-        IMatch elementMatch_p, EReference reference_p, EObject value_p, IMatch valueMatch_p,
-        Role presenceRole_p, boolean isOrder_p);
+    IReferenceValuePresence<E> newReferenceValuePresence(
+        IMatch<E> elementMatch_p, Object reference_p, E value_p,
+        IMatch<E> valueMatch_p, Role presenceRole_p, boolean isOrder_p);
     
     /**
      * Swap the TARGET and REFERENCE scopes.
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IDataPolicy.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IDataPolicy.java
new file mode 100644
index 0000000..996ce87
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IDataPolicy.java
@@ -0,0 +1,176 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.api;
+
+import java.util.Collection;
+
+import org.eclipse.emf.diffmerge.generic.api.scopes.IEditableDataScope;
+
+
+/**
+ * A policy that handles meta or schema-related aspects as well as technological aspects
+ * of data scopes.
+ * It defines rules for structural constraints. It provides ID management, element
+ * creation mechanisms and other meta information.
+ * It typically reflects aspects of the underlying data technology that must be taken
+ * into account by a diff/merge engine. It is typically implemented once for a family
+ * of technologically homogeneous scopes.
+ * Methods that deal with meta aspects are prefixed with "m".
+ * Methods that deal with technical aspects are prefixed with "t".
+ * 
+ * @param <E> The type of data elements.
+ * 
+ * @author Matthieu Helleboid
+ * @author Olivier Constant
+ */
+public interface IDataPolicy<E> {
+  
+  /**
+   * Return the set of attributes which are applicable to the given element.
+   * @param element_p a non-null element
+   * @return a non-null, potentially empty, unmodifiable ordered set
+   */
+  Collection<?> mGetAttributes(E element_p);
+  
+  /**
+   * Return the opposite of the given reference, if any.
+   * Opposite references manifest bidirectional links between elements and are
+   * thus assumed to be automatically kept in sync by the data technology.
+   * @param reference_p a non-null reference
+   * @return a potentially null reference
+   */
+  Object mGetOppositeReference(Object reference_p);
+  
+  /**
+   * Return the set of references which are applicable to the given element.
+   * @param element_p a non-null element which belongs to getReferences(element_p)
+   * @return a non-null, potentially empty, unmodifiable ordered set
+   */
+  Collection<?> mGetReferences(E element_p);
+  
+  /**
+   * Return an object that represents the type of the given element
+   * @param element_p a non-null element
+   * @return a non-null type
+   */
+  Object mGetType(E element_p);
+  
+  /**
+   * Return whether the given reference is the opposite of a containment.
+   * Class invariant: isContainerReference(r) ==
+   *  getOppositeReference(r) != null &&
+   *    isContainmentReference(getOppositeReference(r))
+   * @see IDataPolicy#mIsContainmentReference(Object)
+   * @see IDataPolicy#mGetOppositeReference(Object)
+   * @param reference_p a non-null reference
+   */
+  boolean mIsContainerReference(Object reference_p);
+  
+  /**
+   * Return whether the given reference manifests a parent-child relationship
+   * in a forest of elements. The data technology is assumed to automatically
+   * preserve the forest structure by, e.g., removing reference values and moving
+   * elements as a result of other changes.
+   * @param reference_p a non-null reference
+   */
+  boolean mIsContainmentReference(Object reference_p);
+  
+  /**
+   * Return whether the given attribute tolerates that its values be changed
+   * @param attribute_p a non-null attribute
+   */
+  boolean mIsChangeableAttribute(Object attribute_p);
+  
+  /**
+   * Return whether the given reference tolerates that its values be changed
+   * @param reference_p a non-null reference
+   */
+  boolean mIsChangeableReference(Object reference_p);
+  
+  /**
+   * Return whether the given attribute stores intrinsic IDs, that is,
+   * IDs for the owning elements that are unique within the data scope.
+   * @param attribute_p a non-null attribute
+   */
+  boolean mIsIDAttribute(Object attribute_p);
+  
+  /**
+   * Return whether the given attribute tolerates more than one value on the
+   * same element
+   * @param attribute_p a non-null attribute
+   */
+  boolean mIsManyAttribute(Object attribute_p);
+  
+  /**
+   * Return whether the given reference tolerates more than one value on the
+   * same element
+   * @param reference_p a non-null reference
+   */
+  boolean mIsManyReference(Object reference_p);
+  
+  /**
+   * Return whether the given attribute tolerates zero value
+   * @param attribute_p a non-null attribute
+   */
+  boolean mIsOptionalAttribute(Object attribute_p);
+  
+  /**
+   * Return whether the given reference tolerates zero value
+   * @param reference_p a non-null reference
+   */
+  boolean mIsOptionalReference(Object reference_p);
+  
+  /**
+   * Return the ID of the given element, if any
+   * @param element_p a non-null element
+   * @param intrinsic_p whether an intrinsic (attribute-based) ID must be returned,
+   *          or extrinsic (dependent on the persistence layer)
+   * @return a potentially null object
+   */
+  Object tGetID(E element_p, boolean intrinsic_p);
+  
+  /**
+   * Return whether elements in a scope must be disconnected from others, in terms of
+   * reference values, prior to their removal
+   * @see IEditableDataScope#disconnect(Object)
+   */
+  boolean tIsElementDisconnectionRequired();
+  
+  /**
+   * Return whether a value of the given cross-reference must be explicitly deleted
+   * when the value element is deleted. This operation aims at enabling the usage context
+   * to determine what connections (reference values) must be removed prior to element removals.
+   * If !tIsElementDisconnectionRequired(), then this operation has no impact.
+   * @param reference_p a non-null reference
+   */
+  boolean tIsReferenceDisconnectionRequired(Object reference_p);
+  
+  /**
+   * Create and return a new bare element, i.e., an element without particular values
+   * on its attributes or references, as the match of the given source element.
+   * Note that the given source element may be of any arbitrary nature.
+   * @param source_p a non-null object
+   * @return an element that cannot be null
+   */
+  E tNewBareElement(Object source_p);
+  
+  /**
+   * Set the ID of the given element
+   * @param element_p a non-null element
+   * @param id_p a potentially null object
+   * @param intrinsic_p whether the intrinsic (attribute-based) or extrinsic
+   *          (dependent on the persistence layer) ID is concerned
+   * @return a potentially null object
+   */
+  boolean tSetID(E element_p, Object id_p, boolean intrinsic_p);
+  
+}
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IDiffPolicy.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IDiffPolicy.java
new file mode 100644
index 0000000..032ab4f
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IDiffPolicy.java
@@ -0,0 +1,115 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.api;
+
+import org.eclipse.emf.diffmerge.generic.api.scopes.ITreeDataScope;
+
+/**
+ * A policy that alters the construction of differences between data scopes
+ * in a comparison.
+ * 
+ * @param <E> The type of data elements.
+ * 
+ * @author Olivier Constant
+ */
+public interface IDiffPolicy<E> {
+  
+  /**
+   * Return whether the given attribute values must be considered equal
+   * @param value1_p the first non-null attribute value
+   * @param value2_p the second non-null attribute value
+   * @param attribute_p the non-null attribute concerned
+   * @param scope_p the non-null scope the attribute is from
+   */
+  boolean considerEqual(Object value1_p, Object value2_p, Object attribute_p,
+      ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return whether the given out-of-scope value must be considered equal to the
+   * given candidate value. True may only be returned if the candidate value is also
+   * out of scope.
+   * @param outOfScopeValue_p the non-null out-of-scope value
+   * @param candidateValue_p the non-null other value
+   * @param reference_p the non-null reference concerned
+   * @param scope_p the non-null scope the candidate value belongs to
+   */
+  boolean considerEqualOutOfScope(E outOfScopeValue_p, E candidateValue_p,
+      Object reference_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return whether the given attribute must be considered as ordered
+   * @param attribute_p a non-null attribute within this scope
+   * @param scope_p the non-null scope the attribute is from
+   */
+  boolean considerOrderedAttribute(Object attribute_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return whether the given reference must be considered as ordered
+   * @param reference_p a reference within this scope
+   *        (null stands for root containment)
+   * @param scope_p the non-null scope the reference is from
+   */
+  boolean considerOrderedReference(Object reference_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return whether the given attribute must be covered by the difference
+   * detection algorithm
+   * @param attribute_p a non-null attribute
+   * @param scope_p the non-null scope the attribute is from
+   */
+  boolean coverAttribute(Object attribute_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return whether the given match must be covered by the difference detection
+   * algorithm
+   * @param match_p a non-null match
+   */
+  boolean coverMatch(IMatch<E> match_p);
+  
+  /**
+   * Return whether the given element, even though it is outside the TARGET and
+   * REFERENCE scopes, must be taken into account when it is a value of the given reference.
+   * If so, then corresponding differences can be detected and merging them means copying
+   * references to the element as they are. If not, then those differences are ignored.
+   * If the element belongs to either scope, then the value returned by this operation
+   * has no impact.
+   * Precondition: coverFeature(reference_p)
+   * @param value_p a non-null element
+   * @param reference_p a non-null reference
+   * @param scope_p the non-null scope value_p belongs to
+   */
+  boolean coverOutOfScopeValue(E value_p, Object reference_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return whether the given reference must be covered by the difference
+   * detection algorithm.
+   * Precondition: 
+   *  !scope_p.mIsContainmentReference(reference_p) &&
+   *    !scope_p.mIsContainerReference(reference_p)
+   * In other terms, this method is never called for containment or container
+   * references. This is because those are implicitly determined by the elements
+   * that are present in the compared model scopes.
+   * @param reference_p a non-null reference
+   * @param scope_p the non-null scope the reference is from
+   */
+  boolean coverReference(Object reference_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return whether the given value is significant for the given attribute.
+   * If not, then its presence is ignored.
+   * @param value_p a non-null attribute value
+   * @param attribute_p a non-null attribute
+   * @param scope_p the non-null scope the attribute is from
+   */
+  boolean coverValue(Object value_p, Object attribute_p, ITreeDataScope<E> scope_p);
+  
+}
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMapping.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMapping.java
similarity index 75%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMapping.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMapping.java
index b596229..1e60544 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMapping.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMapping.java
@@ -9,36 +9,37 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api;
+package org.eclipse.emf.diffmerge.generic.api;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.util.EMap;
-import org.eclipse.emf.diffmerge.api.scopes.IModelScope;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature.Setting;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IRawDataScope;
 
 
 /**
- * A mapping between model scopes which is such that every element of either scope
+ * A mapping between data scopes which is such that every element of either scope
  * is mapped at most once.
  * A mapping is defined as a set of IMatch.
+ * 
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IMapping {
+public interface IMapping<E> {
   
   /**
    * Return whether the given element is covered by this mapping in the given role
    * @param element_p a non-null element
    * @param role_p a non-null role
    */
-  boolean covers(EObject element_p, Role role_p);
+  boolean covers(E element_p, Role role_p);
   
   /**
    * Return the comparison this mapping belongs to
    * @return a non-null comparison
    */
-  IComparison getComparison();
+  IComparison<E> getComparison();
   
   /**
    * Return the formerly partial matches which have been completed
@@ -48,7 +49,7 @@
    * @param destinationRole_p a role which is TARGET or REFERENCE
    * @return a non-null, potentially empty, unmodifiable collection
    */
-  Collection<IMatch> getCompletedMatches(Role destinationRole_p);
+  Collection<IMatch<E>> getCompletedMatches(Role destinationRole_p);
   
   /**
    * Return the content of this mapping.
@@ -56,24 +57,16 @@
    * matches of its children in side getOrderingRole().
    * @return a non-null, potentially empty, unmodifiable collection of matches
    */
-  Collection<IMatch> getContents();
+  Collection<IMatch<E>> getContents();
   
   /**
-   * Return the cross-references to the given element in the given role which are not covered by differences
-   * @param element_p a non-null element
-   * @param role_p a role which is TARGET or REFERENCE
-   * @return a non-null, potentially empty, unmodifiable collection
-   */
-  Collection<Setting> getCrossReferences(EObject element_p, Role role_p);
-  
-  /**
-   * Return the match for the given element playing the given role,
-   * or null if no such match exists or if any of the parameters is null
-   * @param element_p a potentially null element
+   * Return the match for the given object playing the given role,
+   * or null if no such match exists, or any of the parameters is null
+   * @param potentialElement_p a potentially null object that may be a data element
    * @param role_p a potentially null role
    * @return a potentially null match
    */
-  IMatch getMatchFor(EObject element_p, Role role_p);
+  IMatch<E> getMatchFor(Object potentialElement_p, Role role_p);
   
   /**
    * Return the number of non-partial matches in this mapping
@@ -99,7 +92,7 @@
    * @param scope_p a non-null model scope
    * @param role_p a non-null comparison role
    */
-  boolean isCompleteFor(IModelScope scope_p, Role role_p);
+  boolean isCompleteFor(IRawDataScope<E> scope_p, Role role_p);
   
   /**
    * Return whether this mapping is empty
@@ -112,7 +105,7 @@
    * @param target_p a potentially null element playing the TARGET role
    * @param reference_p a potentially null element playing the REFERENCE role
    */
-  boolean maps(EObject target_p, EObject reference_p);
+  boolean maps(E target_p, E reference_p);
   
   /**
    * Return whether there is a match corresponding to the given elements.
@@ -121,7 +114,7 @@
    * @param reference_p a potentially null element playing the REFERENCE role
    * @param ancestor_p a potentially null element playing the ANCESTOR role
    */
-  boolean maps(EObject target_p, EObject reference_p, EObject ancestor_p);
+  boolean maps(E target_p, E reference_p, E ancestor_p);
   
   /**
    * Return whether there is a match corresponding to the given elements for
@@ -132,7 +125,7 @@
    * @param element2_p a potentially null element playing role role2_p
    * @param role2_p a non-null role which is different from role1_p
    */
-  boolean maps(EObject element1_p, Role role1_p, EObject element2_p, Role role2_p);
+  boolean maps(E element1_p, Role role1_p, E element2_p, Role role2_p);
   
   /**
    * Return the number of matches, partial or not, in this mapping
@@ -155,14 +148,14 @@
    * @return a non-null, unmodifiable map based on equality by object reference
    *         which is not kept in sync with the mapping
    */
-  EMap<EObject, EObject> toMap(Role keyRole_p, Role valueRole_p);
+  EMap<E, E> toMap(Role keyRole_p, Role valueRole_p);
   
   
   /**
    * A mapping with editing features.
    * All concrete classes implementing IMapping must also implement this interface.
    */
-  interface Editable extends IMapping {
+  interface Editable<E> extends IMapping<E> {
     
     /**
      * Clear this mapping
@@ -177,7 +170,7 @@
      * @param partialMatch_p a non-null match such that partialMatch_p.isPartial()
      * @return a non-null element which is a clone of the element in partialMatch_p
      */
-    EObject completeMatch(IMatch partialMatch_p);
+    E completeMatch(IMatch<E> partialMatch_p);
     
     /**
      * Complete the references between all completed elements in the given role
@@ -186,15 +179,9 @@
     void completeReferences(Role role_p);
     
     /**
-     * Register cross-references which are not covered by differences
-     * @param role_p a role which is TARGET or REFERENCE
+     * @see org.eclipse.emf.diffmerge.generic.api.IMapping#getComparison()
      */
-    void crossReference(Role role_p);
-    
-    /**
-     * @see org.eclipse.emf.diffmerge.api.IMapping#getComparison()
-     */
-    IComparison.Editable getComparison();
+    IComparison.Editable<E> getComparison();
     
     /**
      * Return a modifiable collection of the formerly partial matches
@@ -202,14 +189,14 @@
      * @param destinationRole_p a role which is TARGET or REFERENCE
      * @return a non-null, potentially empty, modifiable collection
      */
-    Collection<IMatch> getModifiableCompletedMatches(Role destinationRole_p);
+    Collection<IMatch<E>> getModifiableCompletedMatches(Role destinationRole_p);
     
     /**
      * Return the content of this mapping as a modifiable collection
      * Class invariant: getModifiableContents().equals(getContents())
      * @return a non-null, potentially empty, modifiable collection of matches
      */
-    Collection<? extends IMatch> getModifiableContents();
+    Collection<? extends IMatch<E>> getModifiableContents();
     
     /**
      * Map the given element from the given role to no other element.
@@ -219,7 +206,7 @@
      * @param role_p a non-null role
      * @return the non-null new match
      */
-    IMatch.Editable map(EObject element_p, Role role_p);
+    IMatch.Editable<E> map(E element_p, Role role_p);
     
     /**
      * Map the given elements from the given roles, reusing existing matches
@@ -231,8 +218,8 @@
      * @param role2_p a non-null role which is different from role1_p
      * @return true if a contradicting match existed before, false otherwise
      */
-    boolean mapIncrementally(EObject element1_p, Role role1_p,
-        EObject element2_p, Role role2_p);
+    boolean mapIncrementally(E element1_p, Role role1_p,
+        E element2_p, Role role2_p);
   }
   
 }
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMatch.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMatch.java
similarity index 66%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMatch.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMatch.java
index 8fa9f81..a87f5ea 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMatch.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMatch.java
@@ -9,36 +9,33 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api;
+package org.eclipse.emf.diffmerge.generic.api;
 
 import java.util.Collection;
 import java.util.List;
 
-import org.eclipse.emf.diffmerge.api.diff.IAttributeValuePresence;
-import org.eclipse.emf.diffmerge.api.diff.IDifference;
-import org.eclipse.emf.diffmerge.api.diff.IElementPresence;
-import org.eclipse.emf.diffmerge.api.diff.IReferenceValuePresence;
-import org.eclipse.emf.diffmerge.api.diff.IValuePresence;
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
+import org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence;
+import org.eclipse.emf.diffmerge.generic.api.diff.IDifference;
+import org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence;
+import org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence;
 
 
 /**
  * A match between elements which also contains differences between those elements.
  * @see IPureMatch
+ * 
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IMatch extends IPureMatch {
+public interface IMatch<E> extends IPureMatch<E> {
   
   /**
    * Return all differences which depend on this match (container differences included).
    * The resulting collection may become obsolete if differences are later added.
    * @return a non-null, potentially empty, unmodifiable collection
    */
-  List<IDifference> getAllDifferences();
+  List<IDifference<E>> getAllDifferences();
   
   /**
    * Return the attribute differences associated to the given attribute.
@@ -46,22 +43,33 @@
    * @param attribute_p a non-null attribute
    * @return a non-null, possibly empty, unmodifiable collection
    */
-  Collection<IAttributeValuePresence> getAttributeDifferences(EAttribute attribute_p);
+  Collection<IAttributeValuePresence<E>> getAttributeDifferences(
+      Object attribute_p);
   
   /**
-   * Return the attribute differences associated to the given attribute
+   * Return the attribute difference that represents the holding of the given
+   * value via the given attribute
    * @param attribute_p a non-null attribute
    * @param value_p a non-null object
    * @return a possibly null attribute value presence
    */
-  IAttributeValuePresence getAttributeValueDifference(EAttribute attribute_p, Object value_p);
+  IAttributeValuePresence<E> getAttributeValueDifference(
+      Object attribute_p, Object value_p);
+  
+  /**
+   * Return the order difference on the given attribute in the given role, if any
+   * @param attribute_p a non-null attribute
+   * @param role_p a non-null role which is TARGET or REFERENCE
+   * @return a potentially null value presence such that isOrder()
+   */
+  IAttributeValuePresence<E> getAttributeOrderDifference(Object attribute_p, Role role_p);
   
   /**
    * Return the set of attributes for which differences exist.
    * The resulting collection may become obsolete if differences are later added.
    * @return a non-null, potentially empty, unmodifiable collection
    */
-  Collection<EAttribute> getAttributesWithDifferences();
+  Collection<Object> getAttributesWithDifferences();
   
   /**
    * Return the difference corresponding to the presence of an unmatched
@@ -70,7 +78,7 @@
    *  isPartial() || getElementPresenceDifference() == null
    * @return a potentially null difference
    */
-  IElementPresence getElementPresenceDifference();
+  IElementPresence<E> getElementPresenceDifference();
   
   /**
    * Return the number of differences which are not related to the containment
@@ -84,15 +92,7 @@
    * @param role_p a non-null role which is TARGET or REFERENCE
    * @return a potentially null reference value presence
    */
-  IReferenceValuePresence getOwnershipDifference(Role role_p);
-  
-  /**
-   * Return the order difference on the given feature in the given role, if any
-   * @param feature_p a non-null feature
-   * @param role_p a non-null role which is TARGET or REFERENCE
-   * @return a potentially null value presence such that isOrder()
-   */
-  IValuePresence getOrderDifference(EStructuralFeature feature_p, Role role_p);
+  IReferenceValuePresence<E> getOwnershipDifference(Role role_p);
   
   /**
    * Return the presence differences in the given role which are related to this match.
@@ -100,7 +100,7 @@
    * @param role_p a non-null role
    * @return an unmodifiable non-null collection of differences
    */
-  Collection<IDifference> getPresenceDifferencesIn(Role role_p);
+  Collection<IDifference<E>> getPresenceDifferencesIn(Role role_p);
   
   /**
    * Return the reference differences associated to the given reference.
@@ -108,8 +108,8 @@
    * @param reference_p a non-null reference
    * @return a non-null, possibly empty, unmodifiable collection
    */
-  Collection<IReferenceValuePresence> getReferenceDifferences(
-      EReference reference_p);
+  Collection<IReferenceValuePresence<E>> getReferenceDifferences(
+      Object reference_p);
   
   /**
    * Return the reference difference that represents the referencing of the given
@@ -118,15 +118,23 @@
    * @param value_p a non-null element
    * @return a possibly null reference value presence
    */
-  IReferenceValuePresence getReferenceValueDifference(EReference reference_p,
-      EObject value_p);
+  IReferenceValuePresence<E> getReferenceValueDifference(Object reference_p,
+      E value_p);
+  
+  /**
+   * Return the order difference on the given reference in the given role, if any
+   * @param reference_p a non-null reference
+   * @param role_p a non-null role which is TARGET or REFERENCE
+   * @return a potentially null value presence such that isOrder()
+   */
+  IReferenceValuePresence<E> getReferenceOrderDifference(Object reference_p, Role role_p);
   
   /**
    * Return the set of references for which differences exist.
    * The resulting collection may become obsolete if differences are later added.
    * @return a non-null, potentially empty, unmodifiable collection
    */
-  Collection<EReference> getReferencesWithDifferences();
+  Collection<Object> getReferencesWithDifferences();
   
   /**
    * Return the differences whose origin is this match
@@ -134,7 +142,7 @@
    * The resulting collection may become obsolete if differences are later added.
    * @return a non-null, potentially empty, unmodifiable collection
    */
-  List<IDifference> getRelatedDifferences();
+  List<IDifference<E>> getRelatedDifferences();
   
   /**
    * Return whether this match corresponds to an element which has been moved
@@ -147,19 +155,24 @@
    * A match with editing features.
    * All concrete classes implementing IMatch must also implement this interface.
    */
-  interface Editable extends IMatch, IPureMatch.Editable {
+  interface Editable<E> extends IMatch<E>, IPureMatch.Editable<E> {
     /**
      * Add the given difference to the differences related to this match
      * @param difference_p a non-null difference
      */
-    void addRelatedDifference(IDifference difference_p);
+    void addRelatedDifference(IDifference<E> difference_p);
     
     /**
      * Register the given difference as an ownership difference on this match
      * @param presence_p a non-null reference value presence which is such that
      *                   the reference is a containment and the value is this match
      */
-    void addOwnershipDifference(IReferenceValuePresence presence_p);
+    void addOwnershipDifference(IReferenceValuePresence<E> presence_p);
+    
+    /**
+     * @see org.eclipse.emf.diffmerge.generic.api.IPureMatch#getMapping()
+     */
+    IMapping.Editable<E> getMapping();
   }
   
 }
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMatchPolicy.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMatchPolicy.java
similarity index 85%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMatchPolicy.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMatchPolicy.java
index 8d35943..c13c75d 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMatchPolicy.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMatchPolicy.java
@@ -9,20 +9,22 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api;
+package org.eclipse.emf.diffmerge.generic.api;
 
 import java.util.Comparator;
 
-import org.eclipse.emf.diffmerge.api.scopes.IModelScope;
-import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.diffmerge.generic.api.scopes.ITreeDataScope;
 
 
 /**
- * A policy that defines how model elements from different model scopes are being
+ * A policy that defines how model elements from different data scopes are being
  * matched in a comparison.
+ * 
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IMatchPolicy {
+public interface IMatchPolicy<E> {
   
   /**
    * Return an object ("match ID") which uniquely discriminates the given element
@@ -34,17 +36,17 @@
    * the match policy is considered to be non-applicable to the scope.
    * More formally:
    * Two elements E1, E2 from scopes S1, S2 will match if and only if
-   * getMatchId(E1, S1) != null && getMatchId(E1, S1).equals(getMatchId(E2, S2)).
+   * getMatchID(E1, S1) != null && getMatchID(E1, S1).equals(getMatchID(E2, S2)).
    * Precondition: scope_p.covers(element_p)
    * Class invariant (uniqueness):
    *  FOR EVERY E1, E2 IN scope_p.getAllContentsAsSet() :
-   *  E1 != E2 && getMatchId(E1, scope_p) != null IMPLIES
-   *  !getMatchId(E1, scope_p).equals(getMatchId(E2, scope_p))
+   *  E1 != E2 && getMatchID(E1, scope_p) != null IMPLIES
+   *  !getMatchID(E1, scope_p).equals(getMatchID(E2, scope_p))
    * @param element_p a non-null element
    * @param scope_p a non-null scope
    * @return a potentially null object
    */
-  Object getMatchID(EObject element_p, IModelScope scope_p);
+  Object getMatchID(E element_p, ITreeDataScope<E> scope_p);
   
   /**
    * Optionally return a comparator which is applicable to all objects that getMatchID
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMergePolicy.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMergePolicy.java
new file mode 100644
index 0000000..7a124d8
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMergePolicy.java
@@ -0,0 +1,154 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.api;
+
+import java.util.Collection;
+
+import org.eclipse.emf.diffmerge.generic.api.scopes.ITreeDataScope;
+
+
+/**
+ * A policy that defines how merges are performed in a comparison.
+ * 
+ * @param <E> The type of data elements.
+ * 
+ * @author Olivier Constant
+ */
+public interface IMergePolicy<E> {
+  
+  /**
+   * Return whether a non-root element may only be present in the given scope if its ownership
+   * (value in containment setting) is present
+   * @param scope_p a non-null scope
+   */
+  boolean bindPresenceToOwnership(ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return whether the given attribute must be copied when elements are being copied
+   * to the given scope.
+   * Note that if false is returned for some attributes while the diff policy specifies that
+   * those attributes are covered by the diff phase, then copying an element to the given scope
+   * may result in new differences when the comparison is re-computed.
+   * @see IDiffPolicy#coverAttribute(Object, ITreeDataScope)
+   * @param attribute_p a non-null attribute
+   * @param scope_p a non-null scope
+   */
+  boolean copyAttribute(Object attribute_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return whether the given reference must be copied when elements are being copied
+   * to the given scope.
+   * Note that if false is returned for some references while the diff policy specifies that
+   * those references are covered by the diff phase, then copying an element to the given scope
+   * may result in new differences when the comparison is re-computed.
+   * @see IDiffPolicy#coverReference(Object, ITreeDataScope)
+   * @param reference_p a non-null reference 
+   * @param scope_p a non-null scope
+   */
+  boolean copyReference(Object reference_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return whether cross-references outside the given source scope must be copied when
+   * elements are being copied from the source scope to the given target scope.
+   * @param sourceScope_p a non-null scope
+   * @param targetScope_p a non-null scope
+   */
+  boolean copyOutOfScopeCrossReferences(ITreeDataScope<E> sourceScope_p,
+      ITreeDataScope<E> targetScope_p);
+  
+  /**
+   * Return the set of elements which are essential to the given one, i.e., adding the
+   * given element requires to add the set of elements; conversely, deleting any element
+   * of the set requires to delete the given element
+   * @param element_p a non-null element
+   * @param scope_p a non-null scope to which element_p belongs
+   * @return a non-null, potentially unmodifiable and empty set of elements
+   *         belonging to scope_p
+   */
+  Collection<E> getAdditionGroup(E element_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return the set of elements which must be deleted if the given element is being
+   * deleted, in addition to those the given element is essential to as defined by
+   * getAdditionGroup
+   * @see IMergePolicy#getAdditionGroup(Object, ITreeDataScope)
+   * @param element_p a non-null element
+   * @param scope_p a non-null scope to which element_p belongs
+   * @return a non-null, potentially unmodifiable and empty set of elements
+   *         belonging to scope_p
+   */
+  Collection<E> getDeletionGroup(E element_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return the position that the given value should have among values held by the
+   * given source via the given reference in the given destination role, according to
+   * the position it has in the opposite role in the given comparison
+   * @param comparison_p a non-null comparison
+   * @param destination_p a non-null role which is TARGET or REFERENCE
+   * @param source_p a non-null match
+   * @param reference_p a non-null reference
+   * @param sourceValue_p a non-null value
+   * @return a positive integer (0 inclusive) or -1 if no position could be determined
+   */
+  int getDesiredValuePosition(IComparison<E> comparison_p, Role destination_p,
+      IMatch<E> source_p, Object reference_p, E sourceValue_p);
+  
+  /**
+   * Return whether the given reference is essential to given owner, i.e., adding the reference owner
+   * requires to also add its reference to the values, whether the values are already present or not;
+   * conversely, deleting a reference to any of the values requires to delete the reference owner.
+   * Operation is a special case of IMergePolicy#getAdditionGroup(EObject, IFeaturedModelScope)
+   * when the values are not present, and must be consistent with that operation.
+   * If bindPresenceToOwnership(), operation is only called on cross-references.
+   * @see IMergePolicy#bindPresenceToOwnership(ITreeDataScope)
+   * @param element_p a non-null element
+   * @param reference_p a non-null, non-derived, non-container reference
+   * @param scope_p a non-null scope to which element_p belongs
+   */
+  boolean isMandatoryForAddition(E element_p, Object reference_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Return whether the given reference is mandatory for deletion, i.e., removing the given owner
+   * requires to remove the value(s).
+   * Operation is a special case of IMergePolicy#getDeletionGroup(EObject, IFeaturedModelScope)
+   * and must be consistent with that operation.
+   * @see IMergePolicy#getDeletionGroup(Object, ITreeDataScope)
+   * @param element_p a non-null element
+   * @param reference_p a non-null, non-derived, non-container reference
+   * @param scope_p a non-null scope to which element_p belongs
+   */
+  boolean isMandatoryForDeletion(E element_p, Object reference_p, ITreeDataScope<E> scope_p);
+  
+  /**
+   * Set the ID of the given target element, if possible and relevant.
+   * This operation covers intrinsic (attribute-based) and extrinsic (persistence-specific) IDs.
+   * It is called after the target element has been added to the given target scope as a copy
+   * of the given source element from the given source scope.
+   * Calling this operation multiple times on the same elements must have the same effect as
+   * calling it once (idempotency).
+   * Examples of possible behaviors include: copying ID(s) from the source element to the target
+   * element, creating a new ID for the target element, or, for extrinsic IDs, fully delegating
+   * to the underlying persistence mechanism.
+   * Note that if intrinsic IDs are not copied and the diff policy specifies that ID attributes
+   * are covered by the diff phase, then copying an element to the given target scope will result
+   * in new differences when the comparison is re-computed.
+   * @see IDataPolicy#mIsIDAttribute(Object)
+   * @see IDiffPolicy#coverAttribute(Object, ITreeDataScope)
+   * @param source_p a non-null element
+   * @param sourceScope_p a non-null scope
+   * @param target_p a non-null element
+   * @param targetScope_p a non-null scope
+   */
+  void setID(E source_p, ITreeDataScope<E> sourceScope_p,
+      E target_p, ITreeDataScope<E> targetScope_p);
+  
+}
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMergeSelector.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMergeSelector.java
similarity index 79%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMergeSelector.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMergeSelector.java
index 6b33455..5f21828 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IMergeSelector.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IMergeSelector.java
@@ -9,17 +9,20 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api;
+package org.eclipse.emf.diffmerge.generic.api;
 
-import org.eclipse.emf.diffmerge.api.diff.IDifference;
+import org.eclipse.emf.diffmerge.generic.api.diff.IDifference;
 
 
 /**
  * A decision maker about merging differences.
  * @see IComparison#merge(IMergeSelector, boolean, org.eclipse.core.runtime.IProgressMonitor)
+ *
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IMergeSelector {
+public interface IMergeSelector<E> {
   
   /**
    * Return the role into which the given difference must be merged, if any.
@@ -27,6 +30,6 @@
    * @param difference_p a non-null difference
    * @return a potentially null role, where null stands for no merge
    */
-  Role getMergeDirection(IDifference difference_p);
+  Role getMergeDirection(IDifference<E> difference_p);
   
 }
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IPureMatch.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IPureMatch.java
similarity index 79%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IPureMatch.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IPureMatch.java
index c3075db..b46f594 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/IPureMatch.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/IPureMatch.java
@@ -9,17 +9,20 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api;
+package org.eclipse.emf.diffmerge.generic.api;
 
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.resource.Resource;
-
+import static org.eclipse.emf.diffmerge.generic.api.Role.ANCESTOR;
+import static org.eclipse.emf.diffmerge.generic.api.Role.REFERENCE;
+import static org.eclipse.emf.diffmerge.generic.api.Role.TARGET;
 
 /**
- * A match between model elements that play different roles in a comparison.
+ * A match between data elements that play different roles in a comparison.
+ * 
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IPureMatch {
+public interface IPureMatch<E> {
   
   /**
    * Return whether the receiver involves an element that plays the given role
@@ -38,13 +41,13 @@
    * @param role_p a non-null role
    * @return the element, or null if none
    */
-  EObject get(Role role_p);
+  E get(Role role_p);
   
   /**
    * Return the mapping which owns this match
    * @return a non-null mapping
    */
-  IMapping getMapping();
+  IMapping<E> getMapping();
   
   /**
    * Return the match ID that corresponds to this match, if available
@@ -65,12 +68,6 @@
   int hashCode();
   
   /**
-   * Return whether the receiver maps an element belonging to the given resource.
-   * @param resource_p a potentially null resource
-   */
-  boolean involves(Resource resource_p);
-  
-  /**
    * Return whether the TARGET or REFERENCE role is not covered by this match.
    * Class invariant: isPartial() == getUncoveredRole() != null
    */
@@ -89,7 +86,7 @@
    * @param target_p a potentially null element playing the TARGET role
    * @param reference_p a potentially null element playing the REFERENCE role
    */
-  boolean maps(EObject target_p, EObject reference_p);
+  boolean maps(E target_p, E reference_p);
   
   /**
    * Return whether this match corresponds to the given elements.
@@ -97,14 +94,14 @@
    * @param reference_p a potentially null element playing the REFERENCE role
    * @param ancestor_p a potentially null element playing the ANCESTOR role
    */
-  boolean maps(EObject target_p, EObject reference_p, EObject ancestor_p);
+  boolean maps(E target_p, E reference_p, E ancestor_p);
   
   
   /**
    * A match with editing features.
    * All concrete classes implementing IPureMatch must also implement this interface.
    */
-  interface Editable extends IPureMatch {
+  interface Editable<E> extends IPureMatch<E> {
     /**
      * Reset this match with the given target, reference and ancestor elements
      * Precondition: at least one of the elements is not null
@@ -112,14 +109,19 @@
      * @param reference_p the optional element on the REFERENCE side
      * @param ancestor_p the optional element on the ANCESTOR side
      */
-    void reset(EObject target_p, EObject reference_p, EObject ancestor_p);
+    default void reset(E target_p, E reference_p, E ancestor_p) {
+      assert target_p != null || reference_p != null || ancestor_p != null;
+      set(TARGET, target_p);
+      set(REFERENCE, reference_p);
+      set(ANCESTOR, ancestor_p);
+    }
     
     /**
      * Set the given role to the given element
      * @param role_p a non-null role
      * @param element_p a potentially null element
      */
-    void set(Role role_p, EObject element_p);
+    void set(Role role_p, E element_p);
     
     /**
      * Set the match ID that corresponds to this match
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/Role.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/Role.java
similarity index 97%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/Role.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/Role.java
index ff75081..e502f78 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/Role.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/Role.java
@@ -9,7 +9,7 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api;
+package org.eclipse.emf.diffmerge.generic.api;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IComparisonConfiguration.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IComparisonConfiguration.java
similarity index 69%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IComparisonConfiguration.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IComparisonConfiguration.java
index 862ab06..2468055 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IComparisonConfiguration.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IComparisonConfiguration.java
@@ -9,35 +9,38 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.config;
+package org.eclipse.emf.diffmerge.generic.api.config;
 
-import org.eclipse.emf.diffmerge.api.IDiffPolicy;
-import org.eclipse.emf.diffmerge.api.IMatchPolicy;
-import org.eclipse.emf.diffmerge.api.IMergePolicy;
+import org.eclipse.emf.diffmerge.generic.api.IDiffPolicy;
+import org.eclipse.emf.diffmerge.generic.api.IMatchPolicy;
+import org.eclipse.emf.diffmerge.generic.api.IMergePolicy;
 
 
 /**
  * The configuration of a comparison.
+ *
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IComparisonConfiguration {
+public interface IComparisonConfiguration<E> {
   
   /**
    * Return the diff policy for the comparison
    * @return a potentially null diff policy (null is for default)
    */
-  IDiffPolicy getDiffPolicy();
+  IDiffPolicy<E> getDiffPolicy();
   
   /**
    * Return the match policy for the comparison
    * @return a potentially null match policy (null is for default)
    */
-  IMatchPolicy getMatchPolicy();
+  IMatchPolicy<E> getMatchPolicy();
   
   /**
    * Return the merge policy for the comparison
    * @return a potentially null merge policy (null is for default)
    */
-  IMergePolicy getMergePolicy();
+  IMergePolicy<E> getMergePolicy();
   
 }
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IComparisonConfigurator.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IComparisonConfigurator.java
similarity index 88%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IComparisonConfigurator.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IComparisonConfigurator.java
index 7a1e9fd..576ab8f 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IComparisonConfigurator.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IComparisonConfigurator.java
@@ -9,7 +9,7 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.config;
+package org.eclipse.emf.diffmerge.generic.api.config;
 
 import java.util.List;
 
@@ -25,14 +25,14 @@
    * @param configuration_p a non-null configuration
    * @return whether the operation fully succeeded
    */
-  boolean apply(IComparisonConfiguration configuration_p);
+  boolean apply(IComparisonConfiguration<?> configuration_p);
   
   /**
    * Return whether the given configuration complies with this configurator,
    * i.e., applying the configurator would not make any change to the configuration
    * @param configuration_p a non-null configuration
    */
-  boolean isCompliant(IComparisonConfiguration configuration_p);
+  boolean isCompliant(IComparisonConfiguration<?> configuration_p);
   
   
   /**
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IConfigurablePolicy.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IConfigurablePolicy.java
similarity index 96%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IConfigurablePolicy.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IConfigurablePolicy.java
index 7310651..0001765 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IConfigurablePolicy.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IConfigurablePolicy.java
@@ -9,7 +9,7 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.config;
+package org.eclipse.emf.diffmerge.generic.api.config;
 
 
 /**
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IConfigurationElement.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IConfigurationElement.java
similarity index 94%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IConfigurationElement.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IConfigurationElement.java
index 6168189..5fb74cf 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/config/IConfigurationElement.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/config/IConfigurationElement.java
@@ -9,7 +9,7 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.config;
+package org.eclipse.emf.diffmerge.generic.api.config;
 
 
 /**
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IAttributeValuePresence.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IAttributeValuePresence.java
similarity index 60%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IAttributeValuePresence.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IAttributeValuePresence.java
index a983572..0724946 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IAttributeValuePresence.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IAttributeValuePresence.java
@@ -9,29 +9,25 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.diff;
-
-import org.eclipse.emf.ecore.EAttribute;
+package org.eclipse.emf.diffmerge.generic.api.diff;
 
 
 /**
  * A difference which represents the unmatched presence of an attribute value.
+ *
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IAttributeValuePresence extends IValuePresence {
+public interface IAttributeValuePresence<E> extends IValuePresence<E> {
   
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IValuePresence#getFeature()
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence#getSymmetrical()
    */
-  EAttribute getFeature();
+  IAttributeValuePresence<E> getSymmetrical();
   
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IValuePresence#getSymmetrical()
-   */
-  IAttributeValuePresence getSymmetrical();
-  
-  /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IValuePresence#getValue()
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence#getValue()
    * @return a non-null object
    */
   Object getValue();
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IDifference.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IDifference.java
similarity index 88%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IDifference.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IDifference.java
index dbd9895..7a92b86 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IDifference.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IDifference.java
@@ -9,10 +9,10 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.diff;
+package org.eclipse.emf.diffmerge.generic.api.diff;
 
-import org.eclipse.emf.diffmerge.api.IComparison;
-import org.eclipse.emf.diffmerge.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.IComparison;
+import org.eclipse.emf.diffmerge.generic.api.Role;
 
 
 /**
@@ -20,9 +20,12 @@
  * @see IElementPresence
  * @see IAttributeValuePresence
  * @see IReferenceValuePresence
+ *
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IDifference {
+public interface IDifference<E> {
   
   /**
    * Return whether this difference can be merged to the given role,
@@ -35,7 +38,7 @@
    * Return the comparison to which this difference belongs
    * @return a non-null comparison
    */
-  IComparison getComparison();
+  IComparison<E> getComparison();
   
   /**
    * Return the role into which this difference has been merged, if any.
@@ -72,7 +75,7 @@
    * A difference with editing features.
    * All concrete classes implementing IDifference must also implement this interface.
    */
-  interface Editable extends IDifference {
+  interface Editable<E> extends IDifference<E> {
     /**
      * Specify that this difference is not present in the common ancestor
      * in a three-way comparison
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementPresence.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IElementPresence.java
similarity index 84%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementPresence.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IElementPresence.java
index e722f5a..6c46a67 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementPresence.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IElementPresence.java
@@ -9,10 +9,9 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.diff;
+package org.eclipse.emf.diffmerge.generic.api.diff;
 
-import org.eclipse.emf.diffmerge.api.IMatch;
-import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.diffmerge.generic.api.IMatch;
 
 
 /**
@@ -29,22 +28,24 @@
  *   role is getPresenceRole(), then the element is removed from its scope. The exact
  *   semantics of the removal depends on the scope.
  * 
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IElementPresence extends IElementRelativeDifference,
-IPresenceDifference, IMergeableDifference {
+public interface IElementPresence<E> extends IElementRelativeDifference<E>,
+IPresenceDifference<E>, IMergeableDifference<E> {
   
   /**
    * Return the element whose presence is represented by this difference
    * @return a non-null element
    */
-  EObject getElement();
+  E getElement();
   
   /**
    * Return the match for the owner of the element
    * @return a potentially null match
    */
-  IMatch getOwnerMatch();
+  IMatch<E> getOwnerMatch();
   
   /**
    * Return whether the element is a root in its scope.
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementRelativeDifference.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IElementRelativeDifference.java
similarity index 79%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementRelativeDifference.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IElementRelativeDifference.java
index 11d2587..f07f69e 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementRelativeDifference.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IElementRelativeDifference.java
@@ -9,23 +9,26 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.diff;
+package org.eclipse.emf.diffmerge.generic.api.diff;
 
-import org.eclipse.emf.diffmerge.api.IMatch;
+import org.eclipse.emf.diffmerge.generic.api.IMatch;
 
 
 /**
  * A model difference which is relative to at most one element per role.
+ *
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IElementRelativeDifference extends IDifference {
+public interface IElementRelativeDifference<E> extends IDifference<E> {
   
   /**
    * Return the match which defines the element, or the matching elements,
    * to which this difference is relative
    * @return a match which is non-null unless it represents the model root container
    */
-  IMatch getElementMatch();
+  IMatch<E> getElementMatch();
   
   /**
    * Return whether this difference, if merged, does not affect the containment tree
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementRelativePresence.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IElementRelativePresence.java
similarity index 76%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementRelativePresence.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IElementRelativePresence.java
index b4cb5a2..6104283 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementRelativePresence.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IElementRelativePresence.java
@@ -9,15 +9,18 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.diff;
+package org.eclipse.emf.diffmerge.generic.api.diff;
 
 
 /**
  * A difference which is relative to some unmatched presence on at most one element per role.
+ *
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IElementRelativePresence
-extends IElementRelativeDifference, IPresenceDifference {
+public interface IElementRelativePresence<E>
+extends IElementRelativeDifference<E>, IPresenceDifference<E> {
   
   // Nothing specific
   
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IMergeableDifference.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IMergeableDifference.java
similarity index 82%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IMergeableDifference.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IMergeableDifference.java
index 62149ce..7d4d528 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IMergeableDifference.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IMergeableDifference.java
@@ -9,18 +9,21 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.diff;
+package org.eclipse.emf.diffmerge.generic.api.diff;
 
 import java.util.Collection;
 
-import org.eclipse.emf.diffmerge.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.Role;
 
 
 /**
  * A model difference with features related to merging.
+ *
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IMergeableDifference extends IDifference {
+public interface IMergeableDifference<E> extends IDifference<E> {
   
   /**
    * Return the differences which have been marked as direcly, explicitly
@@ -29,7 +32,7 @@
    * @param role_p a non-null role which is TARGET or REFERENCE
    * @return a non-null, possibly empty, non-modifiable set
    */
-  Collection<IMergeableDifference> getDirectRequiresDependencies(Role role_p);
+  Collection<IMergeableDifference<E>> getDirectRequiresDependencies(Role role_p);
   
   /**
    * Return the differences which have been marked as directly, implicitly
@@ -37,7 +40,7 @@
    * @param role_p a non-null role which is TARGET or REFERENCE
    * @return a non-null, possibly empty, non-modifiable set
    */
-  Collection<IMergeableDifference> getDirectImpliesDependencies(Role role_p);
+  Collection<IMergeableDifference<E>> getDirectImpliesDependencies(Role role_p);
   
   /**
    * Return all the differences which are required to be explicitly merged
@@ -47,7 +50,7 @@
    * @return a non-null, potentially empty, unmodifiable set which
    *         does not contain the receiver
    */
-  Collection<IMergeableDifference> getRequiresDependencies(Role role_p);
+  Collection<IMergeableDifference<E>> getRequiresDependencies(Role role_p);
   
   /**
    * Return all the differences which would be implicitly merged (due
@@ -59,7 +62,7 @@
    * @return a non-null, potentially empty, unmodifiable set which
    *         does not contain the receiver
    */
-  Collection<IMergeableDifference> getImpliesDependencies(Role role_p);
+  Collection<IMergeableDifference<E>> getImpliesDependencies(Role role_p);
   
   /**
    * Merge this difference to the given role. The precise semantics of this operation
@@ -70,14 +73,15 @@
    * @return a non-null, unmodifiable set of the differences which have been merged
    *         implicitly or explicitly, which contains at least this difference
    */
-  Collection<IDifference> mergeTo(Role destination_p);
+  Collection<IDifference<E>> mergeTo(Role destination_p);
   
   
   /**
    * A mergeable difference with editing features.
    * All concrete classes implementing IMergeableDifference must also implement this interface.
    */
-  interface Editable extends IMergeableDifference, IDifference.Editable {
+  interface Editable<E> extends IMergeableDifference<E>,
+  IDifference.Editable<E> {
     /**
      * Core behavior for mergeTo(Role) independently of the current state
      * of the difference (related differences, merge status, etc.)
@@ -97,7 +101,7 @@
      * @param difference_p a non-null difference
      * @param role_p a non-null role which is TARGET or REFERENCE
      */
-    void markImplies(IMergeableDifference difference_p, Role role_p);
+    void markImplies(IMergeableDifference<E> difference_p, Role role_p);
     
     /**
      * Mark the given difference as directly, explicitly dependent upon
@@ -107,7 +111,7 @@
      * @param difference_p a non-null difference
      * @param role_p a non-null role which is TARGET or REFERENCE
      */
-    void markRequires(IMergeableDifference difference_p, Role role_p);
+    void markRequires(IMergeableDifference<E> difference_p, Role role_p);
   }
   
 }
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IPresenceDifference.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IPresenceDifference.java
new file mode 100644
index 0000000..a712fed
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IPresenceDifference.java
@@ -0,0 +1,42 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.api.diff;
+
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.scopes.ITreeDataScope;
+
+
+/**
+ * A model difference which is relative to the presence of elements or values
+ * in a given role.
+ *
+ * @param <E> The type of data elements.
+ * 
+ * @author Olivier Constant
+ */
+public interface IPresenceDifference<E> extends IDifference<E> {
+  
+  /**
+   * Return the role in which the presence is effective
+   * @return Role.TARGET or Role.REFERENCE
+   */
+  Role getPresenceRole();
+  
+  /**
+   * Return the data scope in which the presence is effective
+   * @return a non-null scope
+   */
+  default ITreeDataScope<E> getPresenceScope() {
+    return getComparison().getScope(getPresenceRole());
+  }
+  
+}
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IReferenceValuePresence.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IReferenceValuePresence.java
similarity index 68%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IReferenceValuePresence.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IReferenceValuePresence.java
index 143d782..aa02ca9 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IReferenceValuePresence.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IReferenceValuePresence.java
@@ -9,36 +9,33 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.diff;
+package org.eclipse.emf.diffmerge.generic.api.diff;
 
-import org.eclipse.emf.diffmerge.api.IDiffPolicy;
-import org.eclipse.emf.diffmerge.api.IMatch;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.diffmerge.generic.api.IDiffPolicy;
+import org.eclipse.emf.diffmerge.generic.api.IMatch;
+import org.eclipse.emf.diffmerge.generic.api.scopes.ITreeDataScope;
 
 
 /**
  * A difference which represents the unmatched presence of a reference value
  * (an element being referenced).
+ *
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IReferenceValuePresence extends IValuePresence {
-  
-  /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IValuePresence#getFeature()
-   */
-  EReference getFeature();
+public interface IReferenceValuePresence<E> extends IValuePresence<E> {
   
   /**
    * Return the difference corresponding to the opposite side of the same link, if any
    * @return a potentially null reference value presence
    */
-  IReferenceValuePresence getOpposite();
+  IReferenceValuePresence<E> getOpposite();
   
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IValuePresence#getSymmetrical()
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence#getSymmetrical()
    */
-  IReferenceValuePresence getSymmetrical();
+  IReferenceValuePresence<E> getSymmetrical();
   
   /**
    * Return the difference, if any, which is the symmetrical ownership
@@ -48,12 +45,12 @@
    *                      isSymmetricalOwnershipTo(getSymmetricalOwnership())
    * @return a potentially null reference value presence
    */
-  IReferenceValuePresence getSymmetricalOwnership();
+  IReferenceValuePresence<E> getSymmetricalOwnership();
   
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IValuePresence#getValue()
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence#getValue()
    */
-  EObject getValue();
+  E getValue();
   
   /**
    * Return the match that corresponds to the value, if any.
@@ -61,7 +58,7 @@
    *  isOutOfScope() || getValueMatch().get(getPresenceRole()) == getValue()
    * @return a match that is non-null if and only if the value is in the presence scope
    */
-  IMatch getValueMatch();
+  IMatch<E> getValueMatch();
   
   /**
    * Return whether the reference of this value presence represents a containment,
@@ -74,7 +71,7 @@
    * the same link as this difference on the opposite reference
    * @param peer_p a non-null reference value presence
    */
-  boolean isOppositeOf(IReferenceValuePresence peer_p);
+  boolean isOppositeOf(IReferenceValuePresence<E> peer_p);
   
   /**
    * Return whether the value is outside the presence scope.
@@ -82,23 +79,25 @@
    *    isOutOfScope() == (getValueMatch() == null)
    * Class invariant:
    *    !isOutOfScope() || getFeature() != null
-   * @see IDiffPolicy#coverOutOfScopeValue(EObject, EReference)
+   * @see IDiffPolicy#coverOutOfScopeValue(Object, Object, ITreeDataScope)
    */
   boolean isOutOfScope();
   
   /**
    * Return whether this reference value presence represents an ownership,
    * i.e., it represents an arc in the containment tree.
-   * Class invariant: isOwnership() == !isOrder() && isContainment()
+   * Class invariant: isOwnership() == (!isOrder() && isContainment())
    */
   boolean isOwnership();
   
   /**
    * Return whether the given reference value presence corresponds to
    * the symmetrical ownership of the same value.
-   * Postcondition: !result || isOwnership()
+   * Postcondition: !result || isOwnership() &&
+   *  getValueMatch() != null && getValueMatch() == peer_p.getValueMatch() &&
+   *  getPresenceRole() == peer_p.getPresenceRole().opposite()
    * @param peer_p a non-null reference value presence
    */
-  boolean isSymmetricalOwnershipTo(IReferenceValuePresence peer_p);
+  boolean isSymmetricalOwnershipTo(IReferenceValuePresence<E> peer_p);
   
 }
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IValuePresence.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IValuePresence.java
similarity index 74%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IValuePresence.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IValuePresence.java
index 0d5a009..9ba9a54 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IValuePresence.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/diff/IValuePresence.java
@@ -9,31 +9,32 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.diff;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
+package org.eclipse.emf.diffmerge.generic.api.diff;
 
 
 /**
  * A difference which is due to the unmatched presence of a value on some feature
  * in a given comparison role.
+ *
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IValuePresence extends IElementRelativeDifference,
-IPresenceDifference, IMergeableDifference {
+public interface IValuePresence<E> extends IElementRelativeDifference<E>,
+IPresenceDifference<E>, IMergeableDifference<E> {
   
   /**
    * Return the feature holding the value
    * @return a non-null feature
    */
-  EStructuralFeature getFeature();
+  Object getFeature();
   
   /**
    * Return the difference, if any, which is symmetrical to this one. 
    * @see IValuePresence#isSymmetricalTo(IValuePresence)
    * @return a potentially null value presence (always null if upper bound is not 1 and !isOrder())
    */
-  IValuePresence getSymmetrical();
+  IValuePresence<E> getSymmetrical();
   
   /**
    * Return the non-null value being held
@@ -42,6 +43,17 @@
   Object getValue();
   
   /**
+   * Return whether the feature of this difference tolerates that its values be changed
+   */
+  boolean isChangeableFeature();
+  
+  /**
+   * Return whether the feature of this difference tolerates more than one value on the
+   * same element
+   */
+  boolean isManyFeature();
+  
+  /**
    * Return whether the unmatched presence is solely due to a different ordering.
    * If true, then [getFeature() == null || getFeature().isMany()] and
    * getSymmetrical() returns the opposite ordering difference.
@@ -56,6 +68,6 @@
    * If the feature is many and !isOrder(), then false is always returned.
    * @param peer_p a non-null value presence
    */
-  boolean isSymmetricalTo(IValuePresence peer_p);
+  boolean isSymmetricalTo(IValuePresence<E> peer_p);
   
 }
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IDataScope.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IDataScope.java
new file mode 100644
index 0000000..cef991f
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IDataScope.java
@@ -0,0 +1,59 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.api.scopes;
+
+import java.util.List;
+
+import org.eclipse.emf.diffmerge.generic.api.IDataPolicy;
+
+
+/**
+ * A high-level, technology-agnostic definition of a scope of data.
+ * Data is assumed to be structured as a set of elements that conforms to some schema.
+ * A schema is composed of a set of attributes and a set of references which are
+ * partial functions over the set of elements.
+ * 
+ * - An attribute which is applicable to an element associates the element with a totally
+ * ordered set of elementary values which can be arbitrary objects but cannot be elements
+ * of the scope.
+ * 
+ * - A reference which is applicable to an element associates the element with a totally
+ * ordered set of elements. Elements are thus organized as a graph where each edge is
+ * labeled with a reference of the schema. No particular assumption is made on the graph.
+ * 
+ * All methods in this interface are assumed to have no impact on the observable state
+ * of a data scope. The order in lists is considered to be part of the observable state.
+ * All returned lists are assumed to contain no null values.
+ * 
+ * @param <E> The type of data elements.
+ * 
+ * @author Olivier Constant
+ */
+public interface IDataScope<E> extends IRawDataScope<E>, IDataPolicy<E> {
+  
+  /**
+   * Return the values of the given element w.r.t. the give attribute/
+   * @param element_p a non-null element
+   * @param attribute_p a non-null attribute which belongs to getAttributes(element_p)
+   * @return a non-null, potentially empty, unmodifiable ordered bag
+   */
+  List<?> getAttributeValues(E element_p, Object attribute_p);
+  
+  /**
+   * Return the values of the given element w.r.t. the given reference.
+   * @param element_p a non-null element
+   * @param reference_p a non-null reference
+   * @return a non-null, potentially empty, unmodifiable ordered bag
+   */
+  List<E> getReferenceValues(E element_p, Object reference_p);
+  
+}
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IEditableDataScope.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IEditableDataScope.java
new file mode 100644
index 0000000..6aa89d3
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IEditableDataScope.java
@@ -0,0 +1,106 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.api.scopes;
+
+
+/**
+ * A data scope which can be directly modified.
+ * 
+ * @param <E> The type of data elements.
+ * 
+ * @author Olivier Constant
+ */
+public interface IEditableDataScope<E> extends IDataScope<E>,
+IRawDataScope.Editable<E> {
+  
+  /**
+   * Add the given value to the given element on the given attribute if possible,
+   * otherwise do nothing.
+   * If the given element does not belong to this scope, the behavior of this
+   * operation is undefined.
+   * @param source_p an non-null element
+   * @param attribute_p a non-null attribute
+   * @param value_p a non-null attribute value which is type-compatible with the attribute
+   * @return whether the operation succeeded
+   */
+  boolean addAttributeValue(E source_p, Object attribute_p, Object value_p);
+  
+  /**
+   * Add the given value to the given element on the given reference if possible,
+   * otherwise do nothing.
+   * If the given element does not belong to this scope, the behavior of this
+   * operation is undefined.
+   * If the given value does not belong to the scope, it may belong to it after execution
+   * of this operation as a side effect.
+   * @param source_p an non-null element
+   * @param reference_p a non-null reference
+   * @param value_p a non-null element as value which is type-compatible with the reference
+   * @return whether the operation succeeded
+   */
+  boolean addReferenceValue(E source_p, Object reference_p, E value_p);
+  
+  /**
+   * Disconnect the given element from others prior to its removal.
+   * It may only called if tIsElementDisconnectionRequired() and the usage context
+   * failed to determine what connections (reference values) must be removed.
+   * @param element_p a non-null element
+   * @return whether the operation succeeded
+   */
+  boolean disconnect(E element_p);
+  
+  /**
+   * Move the value held by the given element via the given attribute at the given
+   * position to the given new position.
+   * @param source_p a non-null element
+   * @param attribute_p a non-null attribute
+   * @param newPosition_p a positive int or 0
+   * @param oldPosition_p an arbitrary int, where a negative value stands for the last element
+   * @return the value moved or null if none
+   */
+  Object moveAttributeValue(E source_p, Object attribute_p, int newPosition_p,
+      int oldPosition_p);
+  
+  /**
+   * Move the value held by the given element via the given reference at the given
+   * position to the given new position.
+   * @param source_p a non-null element
+   * @param reference_p a non-null reference
+   * @param newPosition_p a positive int or 0
+   * @param oldPosition_p an arbitrary int, where a negative value stands for the last element
+   * @return the value moved or null if none
+   */
+  E moveReferenceValue(E source_p, Object reference_p, int newPosition_p,
+      int oldPosition_p);
+  
+  /**
+   * Remove the given value on the given attribute from the given element.
+   * If the given element does not belong to this scope, the behavior of this
+   * operation is undefined.
+   * @param source_p a non-null element
+   * @param attribute_p a non-null attribute
+   * @param value_p a non-null value
+   * @return whether the operation succeeded
+   */
+  boolean removeAttributeValue(E source_p, Object attribute_p, Object value_p);
+  
+  /**
+   * Remove the given value on the given reference from the given element.
+   * If the given element does not belong to this scope, the behavior of this
+   * operation is undefined.
+   * @param source_p a non-null element
+   * @param reference_p a non-null reference
+   * @param value_p a non-null element as value
+   * @return whether the operation succeeded
+   */
+  boolean removeReferenceValue(E source_p, Object reference_p, E value_p);
+  
+}
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementRelativePresence.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IEditableTreeDataScope.java
similarity index 63%
copy from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementRelativePresence.java
copy to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IEditableTreeDataScope.java
index b4cb5a2..0484c97 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/api/diff/IElementRelativePresence.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IEditableTreeDataScope.java
@@ -9,16 +9,20 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.api.diff;
+package org.eclipse.emf.diffmerge.generic.api.scopes;
 
 
 /**
- * A difference which is relative to some unmatched presence on at most one element per role.
+ * An IDataScope whose elements are organized as a forest and that can be directly
+ * modified/
+ * 
+ * @param <E> The type of data elements.
+ * 
  * @author Olivier Constant
  */
-public interface IElementRelativePresence
-extends IElementRelativeDifference, IPresenceDifference {
+public interface IEditableTreeDataScope<E> extends ITreeDataScope<E>,
+IEditableDataScope<E> {
   
-  // Nothing specific
+  // Nothing added
   
 }
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IPersistentDataScope.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IPersistentDataScope.java
new file mode 100644
index 0000000..e534731
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IPersistentDataScope.java
@@ -0,0 +1,70 @@
+/*********************************************************************
+ * Copyright (c) 2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.api.scopes;
+
+import java.util.List;
+
+import org.eclipse.core.runtime.IStatus;
+
+/**
+ * A persistence-aware data scope.
+ * 
+ * @author Olivier Constant
+ */
+public interface IPersistentDataScope<E> extends IRawDataScope<E> {
+  
+  /**
+   * Return the root elements of this scope, if any, from a persistence perspective.
+   * In the case where the scope is also an IRawTreeDataScope, this method returns
+   * the physical roots while method {@link IRawTreeDataScope#getRoots()} returns the
+   * logical roots.
+   * @return a non-null, potentially empty list
+   */
+  List<E> getRawRoots();
+  
+  /**
+   * Initialize the scope by loading at least the elements that are required
+   * for exploring the scope
+   * Postcondition: isLoaded() if no exception is thrown
+   * @return a non-null status for the operation
+   */
+  IStatus load();
+  
+  /**
+   * Return whether the scope is loaded, that is, at least the elements that are required for
+   * exploring the scope are loaded
+   */
+  boolean isLoaded();
+  
+  /**
+   * Unload from memory the elements and persistence units that have been loaded as a
+   * result of calling load() and exploring the scope. Elements and persistence units
+   * that were already loaded when load() was called are not unloaded.
+   * A scope which has been unloaded may not be able to be loaded again.
+   * @return a non-null, potentially empty list of persistence units that reflects
+   *          the impact of the operation
+   */
+  List<?> unload();
+  
+  
+  /**
+   * An IPersistentDataScope which can be modified.
+   */
+  interface Editable<E> extends IPersistentDataScope<E> {
+    /**
+     * Save the scope
+     * @return a non-null status for the operation
+     */
+    IStatus save();
+  }
+  
+}
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IRawDataScope.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IRawDataScope.java
new file mode 100644
index 0000000..01f898d
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IRawDataScope.java
@@ -0,0 +1,108 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.api.scopes;
+
+import java.util.Iterator;
+
+
+/**
+ * A high-level, technology-agnostic definition of a scope of data.
+ * Data is not assumed to have any structure other than a decomposition into
+ * atomic elements.
+ * 
+ * All methods in this interface are assumed to have no impact on the observable state
+ * of a raw data scope. The order in returned iterables is considered to be part of the
+ * observable state. All returned iterables are assumed to not contain null values.
+ * 
+ * @param <E> The type of the elements of data scopes.
+ * 
+ * @author Olivier Constant
+ */
+public interface IRawDataScope<E> extends Iterable<E> {
+  
+  /**
+   * Return whether the given element belongs to this set.
+   * This operation is allowed to be computationally expensive.
+   * Postcondition: true is returned if and only if the element is the same as
+   * one of the elements covered by an iterator returned by iterator().
+   * Whether equals(...) or == determines that two elements are the same
+   * is left to the data scope.
+   * @param element_p a non-null element
+   */
+  default boolean covers(E element_p) {
+    // Operator == is used by default for element identification
+    for (E current : this) {
+      if (current == element_p)
+        return true;
+    }
+    return false;
+  }
+  
+  /**
+   * Optionally return an object that characterizes or identifies this data scope.
+   * @return a potentially null object
+   */
+  Object getOriginator();
+  
+  /**
+   * @see java.lang.Iterable#iterator()
+   * Postcondition: remove() is not assumed to be supported by the returned iterator.
+   */
+  Iterator<E> iterator();
+  
+  /**
+   * Return the number of elements in this data scope.
+   * This operation is allowed to be computationally expensive.
+   */
+  default int size() {
+    int result = 0;
+    for (@SuppressWarnings("unused") E element : this) {
+      result++;
+    }
+    return result;
+  }
+  
+  
+  /**
+   * A raw data scope which has the ability to be modified.
+   * @author Olivier Constant
+   */
+  interface Editable<E> extends IRawDataScope<E> {
+    /**
+     * Add the given element to the scope.
+     * Whether its contents belong to the scope after execution is intentionally undefined.
+     * If the element already belongs to the scope, then the behavior of this operation is
+     * undefined.
+     * Postcondition: !result || covers(element_p)
+     * @param element_p a non-null element
+     * @return whether the operation succeeded
+     */
+    boolean add(E element_p);
+    
+   /**
+     * Return whether this scope is read-only, which means that modification operations have
+     * no effect and always return false
+     */
+    boolean isReadOnly();
+    
+    /**
+     * Remove the given element from this scope.
+     * Whether its contents still belong to the scope after execution is intentionally undefined.
+     * Precondition: covers(element_p)
+     * Postcondition: !result || !covers(element_p)
+     * @param element_p a non-null element within the scope
+     * @return whether the operation succeeded
+     */
+    boolean remove(E element_p);
+  }
+  
+}
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IRawTreeDataScope.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IRawTreeDataScope.java
new file mode 100644
index 0000000..5ec47b9
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/IRawTreeDataScope.java
@@ -0,0 +1,74 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.api.scopes;
+
+import java.util.List;
+
+import org.eclipse.emf.common.util.TreeIterator;
+
+
+/**
+ * An IRawDataScope whose elements are organized as a forest (a set of disjoint trees).
+ * All elements of the data set are assumed to be reachable by navigating the forest.
+ * How the underlying data technology enforces, or not, the forest structure is
+ * intentionally left undefined.
+ * 
+ * The forest structure can be used, e.g., for tree-based display in a GUI, and it may
+ * have an impact on the behavior of the data set when modified.
+ * 
+ * All methods in this interface are assumed to have no impact on the observable state
+ * of a data set.
+ * 
+ * @param <E> The type of the elements of data scopes.
+ * 
+ * @author Olivier Constant
+ */
+public interface IRawTreeDataScope<E> extends IRawDataScope<E> {
+  
+  /**
+   * Return an iterator over the subtree rooted at the given element,.
+   * @param element_p a non-null element that belongs to this data scope
+   * @return a non-null iterator that does not support removal
+   */
+  TreeIterator<E> getAllContents(E element_p);
+  
+  /**
+   * Return the children of the given element.
+   * @param element_p a non-null element that belongs to this data scope
+   * @return a non-null, potentially empty, unmodifiable ordered set
+   */
+  List<E> getContents(E element_p);
+  
+  /**
+   * Return the element whose children include the given element, if any.
+   * The returned element must belong to the data scope.
+   * Result must be consistent with getChildren(EObject).
+   * Operation should not be expensive.
+   * Class invariant:
+   *   (this.covers(X) && getContainer(X) == null) == this.getRoots().contains(X)
+   * @param element_p a non-null element which belongs to this data scope
+   * @return a potentially null element
+   */
+  E getContainer(E element_p);
+  
+  /**
+   * Return the root elements of this data scope.
+   * @return a non-null, potentially empty, unmodifiable ordered set
+   */
+  List<E> getRoots();
+  
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.scopes.IRawDataScope#iterator()
+   */
+  TreeIterator<E> iterator();
+  
+}
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/ITreeDataScope.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/ITreeDataScope.java
new file mode 100644
index 0000000..0cfdb3c
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/api/scopes/ITreeDataScope.java
@@ -0,0 +1,47 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.api.scopes;
+
+
+/**
+ * An IDataScope whose elements are organized as a forest (a set of disjoint trees).
+ * A subset of the references are assumed to be 'containment' references, which means
+ * that all edges of the graph labeled by these references belong to the forest.
+ * All elements of the scope are assumed to be reachable by navigating the forest.
+ * How the underlying data technology enforces, or not, the forest structure is
+ * intentionally left undefined.
+ * 
+ * The forest structure can be used, e.g., for tree-based display in a GUI, and it may
+ * have an impact on the behavior of the data scope when modified.
+ * 
+ * All methods in this interface are assumed to have no impact on the observable state
+ * of a data scope.
+ * 
+ * @param <E> The type of data elements.
+ * 
+ * @author Olivier Constant
+ */
+public interface ITreeDataScope<E> extends IDataScope<E>,
+IRawTreeDataScope<E> {
+  
+  /**
+   * Return the containment reference through which the given element is
+   * referenced by its parent, if any.
+   * Result must be consistent with getContainer(EObject).
+   * Postcondition: result == null || isContainment(result)
+   * Postcondition: (result == null) == (getContainer(element_p) == null)
+   * @param element_p a non-null element
+   * @return a potentially null reference
+   */
+  Object getContainment(E element_p);
+  
+}
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GAttributeValuePresence.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GAttributeValuePresence.java
new file mode 100644
index 0000000..e35632d
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GAttributeValuePresence.java
@@ -0,0 +1,53 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>EAttribute Value Presence</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGAttributeValuePresence()
+ * @model abstract="true" superTypes="org.eclipse.emf.diffmerge.generic.gdiffdata.GValuePresence&lt;E, A, R&gt; org.eclipse.emf.diffmerge.generic.gdiffdata.IAttributeValuePresence&lt;E&gt;"
+ * @generated
+ */
+public interface GAttributeValuePresence<E, A, R>
+    extends GValuePresence<E, A, R>, IAttributeValuePresence<E> {
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model valueRequired="true"
+   * @generated
+   */
+  void setValue(Object value);
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model kind="operation" required="true"
+   * @generated
+   */
+  A getFeature();
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model attributeRequired="true"
+   * @generated
+   */
+  void setAttribute(A attribute);
+  // Nothing needed
+} // GAttributeValuePresence
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GComparison.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GComparison.java
new file mode 100644
index 0000000..6e8ef34
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GComparison.java
@@ -0,0 +1,229 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.diffmerge.generic.api.IComparison.Editable;
+import org.eclipse.emf.diffmerge.generic.api.IDiffPolicy;
+import org.eclipse.emf.diffmerge.generic.api.IMatchPolicy;
+import org.eclipse.emf.diffmerge.generic.api.IMergePolicy;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>GComparison</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <!-- begin-model-doc -->
+ * A partial implementation of IComparison based on EMF.
+ * <!-- end-model-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getAncestorScope <em>Ancestor Scope</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getReferenceScope <em>Reference Scope</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getTargetScope <em>Target Scope</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastMatchPolicy <em>Last Match Policy</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastDiffPolicy <em>Last Diff Policy</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastMergePolicy <em>Last Merge Policy</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getMapping <em>Mapping</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGComparison()
+ * @model abstract="true" superTypes="org.eclipse.emf.diffmerge.generic.gdiffdata.GIdentified org.eclipse.emf.diffmerge.generic.gdiffdata.IEditableComparison&lt;E&gt;"
+ * @generated
+ */
+public interface GComparison<E, A, R> extends GIdentified, Editable<E> {
+  /**
+   * Returns the value of the '<em><b>Ancestor Scope</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Ancestor Scope</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Ancestor Scope</em>' attribute.
+   * @see #setAncestorScope(IEditableTreeDataScope)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGComparison_AncestorScope()
+   * @model dataType="org.eclipse.emf.diffmerge.generic.gdiffdata.IEditableTreeDataScope&lt;E&gt;" transient="true"
+   * @generated
+   */
+  IEditableTreeDataScope<E> getAncestorScope();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getAncestorScope <em>Ancestor Scope</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Ancestor Scope</em>' attribute.
+   * @see #getAncestorScope()
+   * @generated
+   */
+  void setAncestorScope(IEditableTreeDataScope<E> value);
+
+  /**
+   * Returns the value of the '<em><b>Reference Scope</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Reference Scope</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Reference Scope</em>' attribute.
+   * @see #setReferenceScope(IEditableTreeDataScope)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGComparison_ReferenceScope()
+   * @model dataType="org.eclipse.emf.diffmerge.generic.gdiffdata.IEditableTreeDataScope&lt;E&gt;" required="true" transient="true"
+   * @generated
+   */
+  IEditableTreeDataScope<E> getReferenceScope();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getReferenceScope <em>Reference Scope</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Reference Scope</em>' attribute.
+   * @see #getReferenceScope()
+   * @generated
+   */
+  void setReferenceScope(IEditableTreeDataScope<E> value);
+
+  /**
+   * Returns the value of the '<em><b>Target Scope</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Target Scope</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Target Scope</em>' attribute.
+   * @see #setTargetScope(IEditableTreeDataScope)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGComparison_TargetScope()
+   * @model dataType="org.eclipse.emf.diffmerge.generic.gdiffdata.IEditableTreeDataScope&lt;E&gt;" required="true" transient="true"
+   * @generated
+   */
+  IEditableTreeDataScope<E> getTargetScope();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getTargetScope <em>Target Scope</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Target Scope</em>' attribute.
+   * @see #getTargetScope()
+   * @generated
+   */
+  void setTargetScope(IEditableTreeDataScope<E> value);
+
+  /**
+   * Returns the value of the '<em><b>Last Match Policy</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Last Match Policy</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Last Match Policy</em>' attribute.
+   * @see #setLastMatchPolicy(IMatchPolicy)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGComparison_LastMatchPolicy()
+   * @model dataType="org.eclipse.emf.diffmerge.generic.gdiffdata.IMatchPolicy&lt;E&gt;" transient="true"
+   * @generated
+   */
+  IMatchPolicy<E> getLastMatchPolicy();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastMatchPolicy <em>Last Match Policy</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Last Match Policy</em>' attribute.
+   * @see #getLastMatchPolicy()
+   * @generated
+   */
+  void setLastMatchPolicy(IMatchPolicy<E> value);
+
+  /**
+   * Returns the value of the '<em><b>Last Diff Policy</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Last Diff Policy</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Last Diff Policy</em>' attribute.
+   * @see #setLastDiffPolicy(IDiffPolicy)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGComparison_LastDiffPolicy()
+   * @model dataType="org.eclipse.emf.diffmerge.generic.gdiffdata.IDiffPolicy&lt;E&gt;" transient="true"
+   * @generated
+   */
+  IDiffPolicy<E> getLastDiffPolicy();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastDiffPolicy <em>Last Diff Policy</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Last Diff Policy</em>' attribute.
+   * @see #getLastDiffPolicy()
+   * @generated
+   */
+  void setLastDiffPolicy(IDiffPolicy<E> value);
+
+  /**
+   * Returns the value of the '<em><b>Last Merge Policy</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Last Merge Policy</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Last Merge Policy</em>' attribute.
+   * @see #setLastMergePolicy(IMergePolicy)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGComparison_LastMergePolicy()
+   * @model dataType="org.eclipse.emf.diffmerge.generic.gdiffdata.IMergePolicy&lt;E&gt;" transient="true"
+   * @generated
+   */
+  IMergePolicy<E> getLastMergePolicy();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastMergePolicy <em>Last Merge Policy</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Last Merge Policy</em>' attribute.
+   * @see #getLastMergePolicy()
+   * @generated
+   */
+  void setLastMergePolicy(IMergePolicy<E> value);
+
+  /**
+   * Returns the value of the '<em><b>Mapping</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Mapping</em>' containment reference isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Mapping</em>' containment reference.
+   * @see #setMapping(GMapping)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGComparison_Mapping()
+   * @model containment="true" required="true"
+   * @generated
+   */
+  GMapping<E, A, R> getMapping();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getMapping <em>Mapping</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Mapping</em>' containment reference.
+   * @see #getMapping()
+   * @generated
+   */
+  void setMapping(GMapping<E, A, R> value);
+
+} // GComparison
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GComparisonElement.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GComparisonElement.java
new file mode 100644
index 0000000..d056f43
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GComparisonElement.java
@@ -0,0 +1,35 @@
+/*********************************************************************
+ * Copyright (c) 2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>GComparison Element</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGComparisonElement()
+ * @model interface="true" abstract="true"
+ * @generated
+ */
+public interface GComparisonElement<E, A, R> extends EObject {
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model kind="operation"
+   * @generated
+   */
+  GComparison<E, A, R> getComparison();
+
+} // GComparisonElement
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GElementPresence.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GElementPresence.java
new file mode 100644
index 0000000..cdf0880
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GElementPresence.java
@@ -0,0 +1,60 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>EElement Presence</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GElementPresence#getOwnerMatch <em>Owner Match</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGElementPresence()
+ * @model abstract="true" superTypes="org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence&lt;E, A, R&gt; org.eclipse.emf.diffmerge.generic.gdiffdata.IElementPresence&lt;E&gt;"
+ * @generated
+ */
+public interface GElementPresence<E, A, R>
+    extends GElementRelativePresence<E, A, R>, IElementPresence<E> {
+  /**
+   * Returns the value of the '<em><b>Owner Match</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Owner Match</em>' reference isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Owner Match</em>' reference.
+   * @see #setOwnerMatch(GMatch)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGElementPresence_OwnerMatch()
+   * @model required="true"
+   * @generated
+   */
+  GMatch<E, A, R> getOwnerMatch();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GElementPresence#getOwnerMatch <em>Owner Match</em>}' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Owner Match</em>' reference.
+   * @see #getOwnerMatch()
+   * @generated
+   */
+  void setOwnerMatch(GMatch<E, A, R> value);
+
+} // GElementPresence
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GElementRelativePresence.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GElementRelativePresence.java
new file mode 100644
index 0000000..d43c28d
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GElementRelativePresence.java
@@ -0,0 +1,88 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativePresence;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>EElement Relative Presence</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence#getElementMatch <em>Element Match</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence#getPresenceRole <em>Presence Role</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGElementRelativePresence()
+ * @model abstract="true" superTypes="org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference&lt;E, A, R&gt; org.eclipse.emf.diffmerge.generic.gdiffdata.IElementRelativePresence&lt;E&gt;"
+ * @generated
+ */
+public interface GElementRelativePresence<E, A, R>
+    extends GMergeableDifference<E, A, R>, IElementRelativePresence<E> {
+  /**
+   * Returns the value of the '<em><b>Element Match</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Element Match</em>' reference isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Element Match</em>' reference.
+   * @see #setElementMatch(GMatch)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGElementRelativePresence_ElementMatch()
+   * @model required="true"
+   * @generated
+   */
+  GMatch<E, A, R> getElementMatch();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence#getElementMatch <em>Element Match</em>}' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Element Match</em>' reference.
+   * @see #getElementMatch()
+   * @generated
+   */
+  void setElementMatch(GMatch<E, A, R> value);
+
+  /**
+   * Returns the value of the '<em><b>Presence Role</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Presence Role</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Presence Role</em>' attribute.
+   * @see #setPresenceRole(Role)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGElementRelativePresence_PresenceRole()
+   * @model dataType="org.eclipse.emf.diffmerge.generic.gdiffdata.Role" required="true"
+   * @generated
+   */
+  Role getPresenceRole();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence#getPresenceRole <em>Presence Role</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Presence Role</em>' attribute.
+   * @see #getPresenceRole()
+   * @generated
+   */
+  void setPresenceRole(Role value);
+
+} // GElementRelativePresence
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GIdentified.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GIdentified.java
new file mode 100644
index 0000000..569a621
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GIdentified.java
@@ -0,0 +1,59 @@
+/*********************************************************************
+ * Copyright (c) 2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>GIdentified</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GIdentified#getId <em>Id</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGIdentified()
+ * @model abstract="true"
+ * @generated
+ */
+public interface GIdentified extends EObject {
+  /**
+   * Returns the value of the '<em><b>Id</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Id</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Id</em>' attribute.
+   * @see #setId(String)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGIdentified_Id()
+   * @model id="true"
+   * @generated
+   */
+  String getId();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GIdentified#getId <em>Id</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Id</em>' attribute.
+   * @see #getId()
+   * @generated
+   */
+  void setId(String value);
+
+} // GIdentified
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GMapping.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GMapping.java
new file mode 100644
index 0000000..b5536f0
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GMapping.java
@@ -0,0 +1,125 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.diffmerge.generic.api.IMatch;
+import org.eclipse.emf.diffmerge.generic.api.IDataPolicy;
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.IMapping.Editable;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>GMapping</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping#getModifiableContents <em>Modifiable Contents</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping#getReferenceCompletedMatches <em>Reference Completed Matches</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping#getTargetCompletedMatches <em>Target Completed Matches</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMapping()
+ * @model abstract="true" superTypes="org.eclipse.emf.diffmerge.generic.gdiffdata.GIdentified org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement&lt;E, A, R&gt; org.eclipse.emf.diffmerge.generic.gdiffdata.IEditableMapping&lt;E&gt;"
+ * @generated
+ */
+public interface GMapping<E, A, R>
+    extends GIdentified, GComparisonElement<E, A, R>, Editable<E> {
+  /**
+   * Returns the value of the '<em><b>Modifiable Contents</b></em>' containment reference list.
+   * The list contents are of type {@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch}<code>&lt;E, A, R&gt;</code>.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Modifiable Contents</em>' containment reference list isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Modifiable Contents</em>' containment reference list.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMapping_ModifiableContents()
+   * @model containment="true"
+   * @generated
+   */
+  EList<GMatch<E, A, R>> getModifiableContents();
+
+  /**
+   * Returns the value of the '<em><b>Reference Completed Matches</b></em>' reference list.
+   * The list contents are of type {@link org.eclipse.emf.diffmerge.generic.api.IMatch}<code>&lt;E&gt;</code>.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Reference Completed Matches</em>' reference list isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Reference Completed Matches</em>' reference list.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMapping_ReferenceCompletedMatches()
+   * @model type="org.eclipse.emf.diffmerge.generic.gdiffdata.IMatch&lt;E&gt;" resolveProxies="false"
+   * @generated
+   */
+  EList<IMatch<E>> getReferenceCompletedMatches();
+
+  /**
+   * Returns the value of the '<em><b>Target Completed Matches</b></em>' reference list.
+   * The list contents are of type {@link org.eclipse.emf.diffmerge.generic.api.IMatch}<code>&lt;E&gt;</code>.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Target Completed Matches</em>' reference list isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Target Completed Matches</em>' reference list.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMapping_TargetCompletedMatches()
+   * @model type="org.eclipse.emf.diffmerge.generic.gdiffdata.IMatch&lt;E&gt;" resolveProxies="false"
+   * @generated
+   */
+  EList<IMatch<E>> getTargetCompletedMatches();
+
+  /**
+   * Remove dependencies (reference values) to the given element so that its removal
+   * from the scope of the given role be possible, if required by the scope.
+   * Dependencies covered by the comparison through reference value presences do not
+   * need to be taken into account. Dependencies that must be taken into account are
+   * those whose removal is necessary to the removal of the element from its scope
+   * AND that are not covered by the comparison, i.e.,
+   * - references from other elements of the scope that, like the element itself, are
+   *    not present in the opposite scope;
+   * - references from other elements of the scope that are ignored due to the diff
+   *    policy;
+   * - references from elements outside the scope.
+   * @param role TARGET or REFERENCE
+   * @param element a non-null element
+   * @return whether all dependencies have been successfully removed or the scope does
+   *          not require it
+   * @see IDataPolicy#tIsElementDisconnectionRequired()
+   * @generated NOT
+   */
+  boolean disconnect(Role role, E element);
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model required="true" sourceRequired="true" referenceRequired="true" valueRequired="true" roleDataType="org.eclipse.emf.diffmerge.generic.gdiffdata.Role" roleRequired="true"
+   * @generated
+   */
+  boolean isIgnoredReferenceValue(E source, R reference, E value, Role role);
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model required="true" elementRequired="true" roleDataType="org.eclipse.emf.diffmerge.generic.gdiffdata.Role" roleRequired="true"
+   * @generated
+   */
+  GMatch<E, A, R> map(E element, Role role);
+
+} // GMapping
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GMatch.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GMatch.java
new file mode 100644
index 0000000..cfc9ebf
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GMatch.java
@@ -0,0 +1,217 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.diffmerge.generic.api.IMatch.Editable;
+import org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence;
+import org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>GMatch</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getMatchID <em>Match ID</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getModifiableRelatedDifferences <em>Modifiable Related Differences</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getElementPresenceDifference <em>Element Presence Difference</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getReferenceOwnershipDifference <em>Reference Ownership Difference</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getTargetOwnershipDifference <em>Target Ownership Difference</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMatch()
+ * @model abstract="true" superTypes="org.eclipse.emf.diffmerge.generic.gdiffdata.GIdentified org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement&lt;E, A, R&gt; org.eclipse.emf.diffmerge.generic.gdiffdata.IEditableMatch&lt;E&gt;"
+ * @generated
+ */
+public interface GMatch<E, A, R>
+    extends GIdentified, GComparisonElement<E, A, R>, Editable<E> {
+  /**
+   * Returns the value of the '<em><b>Match ID</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Match ID</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Match ID</em>' attribute.
+   * @see #setMatchID(Object)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMatch_MatchID()
+   * @model transient="true"
+   * @generated
+   */
+  Object getMatchID();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getMatchID <em>Match ID</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Match ID</em>' attribute.
+   * @see #getMatchID()
+   * @generated
+   */
+  void setMatchID(Object value);
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model kind="operation"
+   * @generated
+   */
+  E getAncestor();
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model kind="operation"
+   * @generated
+   */
+  E getReference();
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model kind="operation"
+   * @generated
+   */
+  E getTarget();
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model
+   * @generated
+   */
+  void setAncestor(E e);
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model
+   * @generated
+   */
+  void setReference(E e);
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model
+   * @generated
+   */
+  void setTarget(E e);
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model kind="operation" required="true"
+   * @generated
+   */
+  GMapping<E, A, R> getMapping();
+
+  /**
+   * Returns the value of the '<em><b>Modifiable Related Differences</b></em>' containment reference list.
+   * The list contents are of type {@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference}<code>&lt;E, A, R&gt;</code>.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Modifiable Related Differences</em>' containment reference list isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Modifiable Related Differences</em>' containment reference list.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMatch_ModifiableRelatedDifferences()
+   * @model containment="true"
+   * @generated
+   */
+  EList<GMergeableDifference<E, A, R>> getModifiableRelatedDifferences();
+
+  /**
+   * Returns the value of the '<em><b>Element Presence Difference</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Element Presence Difference</em>' reference isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Element Presence Difference</em>' reference.
+   * @see #setElementPresenceDifference(IElementPresence)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMatch_ElementPresenceDifference()
+   * @model type="org.eclipse.emf.diffmerge.generic.gdiffdata.IElementPresence&lt;E&gt;"
+   * @generated
+   */
+  IElementPresence<E> getElementPresenceDifference();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getElementPresenceDifference <em>Element Presence Difference</em>}' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Element Presence Difference</em>' reference.
+   * @see #getElementPresenceDifference()
+   * @generated
+   */
+  void setElementPresenceDifference(IElementPresence<E> value);
+
+  /**
+   * Returns the value of the '<em><b>Reference Ownership Difference</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Reference Ownership Difference</em>' reference isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Reference Ownership Difference</em>' reference.
+   * @see #setReferenceOwnershipDifference(IReferenceValuePresence)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMatch_ReferenceOwnershipDifference()
+   * @model type="org.eclipse.emf.diffmerge.generic.gdiffdata.IReferenceValuePresence&lt;E&gt;"
+   * @generated
+   */
+  IReferenceValuePresence<E> getReferenceOwnershipDifference();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getReferenceOwnershipDifference <em>Reference Ownership Difference</em>}' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Reference Ownership Difference</em>' reference.
+   * @see #getReferenceOwnershipDifference()
+   * @generated
+   */
+  void setReferenceOwnershipDifference(IReferenceValuePresence<E> value);
+
+  /**
+   * Returns the value of the '<em><b>Target Ownership Difference</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Target Ownership Difference</em>' reference isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Target Ownership Difference</em>' reference.
+   * @see #setTargetOwnershipDifference(IReferenceValuePresence)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMatch_TargetOwnershipDifference()
+   * @model type="org.eclipse.emf.diffmerge.generic.gdiffdata.IReferenceValuePresence&lt;E&gt;"
+   * @generated
+   */
+  IReferenceValuePresence<E> getTargetOwnershipDifference();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getTargetOwnershipDifference <em>Target Ownership Difference</em>}' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Target Ownership Difference</em>' reference.
+   * @see #getTargetOwnershipDifference()
+   * @generated
+   */
+  void setTargetOwnershipDifference(IReferenceValuePresence<E> value);
+
+} // GMatch
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GMergeableDifference.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GMergeableDifference.java
new file mode 100644
index 0000000..3056b71
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GMergeableDifference.java
@@ -0,0 +1,231 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference;
+import org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>EMergeable Difference</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isAlignedWithAncestor <em>Aligned With Ancestor</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isConflicting <em>Conflicting</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isIgnored <em>Ignored</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getMergeDestination <em>Merge Destination</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getPossibleMergeDestinations <em>Possible Merge Destinations</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getExplicitDependenciesForTarget <em>Explicit Dependencies For Target</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getExplicitDependenciesForReference <em>Explicit Dependencies For Reference</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getImplicitDependenciesForTarget <em>Implicit Dependencies For Target</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getImplicitDependenciesForReference <em>Implicit Dependencies For Reference</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMergeableDifference()
+ * @model abstract="true" superTypes="org.eclipse.emf.diffmerge.generic.gdiffdata.GIdentified org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement&lt;E, A, R&gt; org.eclipse.emf.diffmerge.generic.gdiffdata.IEditableMergeableDifference&lt;E&gt;"
+ * @generated
+ */
+public interface GMergeableDifference<E, A, R>
+    extends GIdentified, GComparisonElement<E, A, R>, Editable<E> {
+  /**
+   * Returns the value of the '<em><b>Aligned With Ancestor</b></em>' attribute.
+   * The default value is <code>"true"</code>.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Aligned With Ancestor</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Aligned With Ancestor</em>' attribute.
+   * @see #setAlignedWithAncestor(boolean)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMergeableDifference_AlignedWithAncestor()
+   * @model default="true" required="true"
+   * @generated
+   */
+  boolean isAlignedWithAncestor();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isAlignedWithAncestor <em>Aligned With Ancestor</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Aligned With Ancestor</em>' attribute.
+   * @see #isAlignedWithAncestor()
+   * @generated
+   */
+  void setAlignedWithAncestor(boolean value);
+
+  /**
+   * Returns the value of the '<em><b>Conflicting</b></em>' attribute.
+   * The default value is <code>"false"</code>.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Conflicting</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Conflicting</em>' attribute.
+   * @see #setConflicting(boolean)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMergeableDifference_Conflicting()
+   * @model default="false" required="true"
+   * @generated
+   */
+  boolean isConflicting();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isConflicting <em>Conflicting</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Conflicting</em>' attribute.
+   * @see #isConflicting()
+   * @generated
+   */
+  void setConflicting(boolean value);
+
+  /**
+   * Returns the value of the '<em><b>Ignored</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Ignored</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Ignored</em>' attribute.
+   * @see #setIgnored(boolean)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMergeableDifference_Ignored()
+   * @model required="true"
+   * @generated
+   */
+  boolean isIgnored();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isIgnored <em>Ignored</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Ignored</em>' attribute.
+   * @see #isIgnored()
+   * @generated
+   */
+  void setIgnored(boolean value);
+
+  /**
+   * Returns the value of the '<em><b>Merge Destination</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Merge Destination</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Merge Destination</em>' attribute.
+   * @see #setMergeDestination(Role)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMergeableDifference_MergeDestination()
+   * @model dataType="org.eclipse.emf.diffmerge.generic.gdiffdata.Role"
+   * @generated
+   */
+  Role getMergeDestination();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getMergeDestination <em>Merge Destination</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Merge Destination</em>' attribute.
+   * @see #getMergeDestination()
+   * @generated
+   */
+  void setMergeDestination(Role value);
+
+  /**
+   * Returns the value of the '<em><b>Possible Merge Destinations</b></em>' attribute list.
+   * The list contents are of type {@link org.eclipse.emf.diffmerge.generic.api.Role}.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Possible Merge Destinations</em>' attribute list isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Possible Merge Destinations</em>' attribute list.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMergeableDifference_PossibleMergeDestinations()
+   * @model dataType="org.eclipse.emf.diffmerge.generic.gdiffdata.Role"
+   * @generated
+   */
+  EList<Role> getPossibleMergeDestinations();
+
+  /**
+   * Returns the value of the '<em><b>Explicit Dependencies For Target</b></em>' reference list.
+   * The list contents are of type {@link org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference}<code>&lt;E&gt;</code>.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Explicit Dependencies For Target</em>' reference list isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Explicit Dependencies For Target</em>' reference list.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMergeableDifference_ExplicitDependenciesForTarget()
+   * @model type="org.eclipse.emf.diffmerge.generic.gdiffdata.IMergeableDifference&lt;E&gt;"
+   * @generated
+   */
+  EList<IMergeableDifference<E>> getExplicitDependenciesForTarget();
+
+  /**
+   * Returns the value of the '<em><b>Explicit Dependencies For Reference</b></em>' reference list.
+   * The list contents are of type {@link org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference}<code>&lt;E&gt;</code>.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Explicit Dependencies For Reference</em>' reference list isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Explicit Dependencies For Reference</em>' reference list.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMergeableDifference_ExplicitDependenciesForReference()
+   * @model type="org.eclipse.emf.diffmerge.generic.gdiffdata.IMergeableDifference&lt;E&gt;"
+   * @generated
+   */
+  EList<IMergeableDifference<E>> getExplicitDependenciesForReference();
+
+  /**
+   * Returns the value of the '<em><b>Implicit Dependencies For Target</b></em>' reference list.
+   * The list contents are of type {@link org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference}<code>&lt;E&gt;</code>.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Implicit Dependencies For Target</em>' reference list isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Implicit Dependencies For Target</em>' reference list.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMergeableDifference_ImplicitDependenciesForTarget()
+   * @model type="org.eclipse.emf.diffmerge.generic.gdiffdata.IMergeableDifference&lt;E&gt;"
+   * @generated
+   */
+  EList<IMergeableDifference<E>> getImplicitDependenciesForTarget();
+
+  /**
+   * Returns the value of the '<em><b>Implicit Dependencies For Reference</b></em>' reference list.
+   * The list contents are of type {@link org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference}<code>&lt;E&gt;</code>.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Implicit Dependencies For Reference</em>' reference list isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Implicit Dependencies For Reference</em>' reference list.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGMergeableDifference_ImplicitDependenciesForReference()
+   * @model type="org.eclipse.emf.diffmerge.generic.gdiffdata.IMergeableDifference&lt;E&gt;"
+   * @generated
+   */
+  EList<IMergeableDifference<E>> getImplicitDependenciesForReference();
+
+} // GMergeableDifference
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GReferenceValuePresence.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GReferenceValuePresence.java
new file mode 100644
index 0000000..52e2a68
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GReferenceValuePresence.java
@@ -0,0 +1,85 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>EReference Value Presence</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GReferenceValuePresence#getValueMatch <em>Value Match</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGReferenceValuePresence()
+ * @model abstract="true" superTypes="org.eclipse.emf.diffmerge.generic.gdiffdata.GValuePresence&lt;E, A, R&gt; org.eclipse.emf.diffmerge.generic.gdiffdata.IReferenceValuePresence&lt;E&gt;"
+ * @generated
+ */
+public interface GReferenceValuePresence<E, A, R>
+    extends GValuePresence<E, A, R>, IReferenceValuePresence<E> {
+
+  /**
+   * Returns the value of the '<em><b>Value Match</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Value Match</em>' reference isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Value Match</em>' reference.
+   * @see #setValueMatch(GMatch)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGReferenceValuePresence_ValueMatch()
+   * @model
+   * @generated
+   */
+  GMatch<E, A, R> getValueMatch();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GReferenceValuePresence#getValueMatch <em>Value Match</em>}' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Value Match</em>' reference.
+   * @see #getValueMatch()
+   * @generated
+   */
+  void setValueMatch(GMatch<E, A, R> value);
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model kind="operation" required="true"
+   * @generated
+   */
+  R getFeature();
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model referenceRequired="true"
+   * @generated
+   */
+  void setReference(R reference);
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model valueRequired="true"
+   * @generated
+   */
+  void setValue(E value);
+  // Nothing needed
+} // GReferenceValuePresence
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GValuePresence.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GValuePresence.java
new file mode 100644
index 0000000..5319ee5
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GValuePresence.java
@@ -0,0 +1,69 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>EValue Presence</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GValuePresence#isOrder <em>Order</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGValuePresence()
+ * @model abstract="true" superTypes="org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence&lt;E, A, R&gt; org.eclipse.emf.diffmerge.generic.gdiffdata.IValuePresence&lt;E&gt;"
+ * @generated
+ */
+public interface GValuePresence<E, A, R>
+    extends GElementRelativePresence<E, A, R>, IValuePresence<E> {
+  /**
+   * Returns the value of the '<em><b>Order</b></em>' attribute.
+   * The default value is <code>"false"</code>.
+   * <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Order</em>' attribute isn't clear,
+   * there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Order</em>' attribute.
+   * @see #setOrder(boolean)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage#getGValuePresence_Order()
+   * @model default="false" required="true"
+   * @generated
+   */
+  boolean isOrder();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GValuePresence#isOrder <em>Order</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Order</em>' attribute.
+   * @see #isOrder()
+   * @generated
+   */
+  void setOrder(boolean value);
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @model kind="operation" required="true"
+   * @generated
+   */
+  Object getFeature();
+
+} // GValuePresence
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GdiffdataFactory.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GdiffdataFactory.java
new file mode 100644
index 0000000..6d652f8
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GdiffdataFactory.java
@@ -0,0 +1,43 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+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.diffmerge.generic.gdiffdata.GdiffdataPackage
+ * @generated
+ */
+public interface GdiffdataFactory extends EFactory {
+  /**
+   * The singleton instance of the factory.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  GdiffdataFactory eINSTANCE = org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataFactoryImpl
+      .init();
+
+  /**
+   * Returns the package supported by this factory.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the package supported by this factory.
+   * @generated
+   */
+  GdiffdataPackage getGdiffdataPackage();
+
+} //GdiffdataFactory
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GdiffdataPackage.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GdiffdataPackage.java
new file mode 100644
index 0000000..190f260
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/GdiffdataPackage.java
@@ -0,0 +1,2655 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+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.diffmerge.generic.gdiffdata.GdiffdataFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface GdiffdataPackage extends EPackage {
+  /**
+   * The package name.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  String eNAME = "gdiffdata"; //$NON-NLS-1$
+
+  /**
+   * The package namespace URI.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  String eNS_URI = "http://www.eclipse.org/emf/diffmerge/generic/gdiffdata/1.0.0"; //$NON-NLS-1$
+
+  /**
+   * The package namespace name.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  String eNS_PREFIX = "org.eclipse.emf.diffmerge.generic"; //$NON-NLS-1$
+
+  /**
+   * The singleton instance of the package.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  GdiffdataPackage eINSTANCE = org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl
+      .init();
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GIdentifiedImpl <em>GIdentified</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GIdentifiedImpl
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGIdentified()
+   * @generated
+   */
+  int GIDENTIFIED = 0;
+
+  /**
+   * The feature id for the '<em><b>Id</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GIDENTIFIED__ID = 0;
+
+  /**
+   * The number of structural features of the '<em>GIdentified</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GIDENTIFIED_FEATURE_COUNT = 1;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GComparisonImpl <em>GComparison</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GComparisonImpl
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGComparison()
+   * @generated
+   */
+  int GCOMPARISON = 1;
+
+  /**
+   * The feature id for the '<em><b>Id</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GCOMPARISON__ID = GIDENTIFIED__ID;
+
+  /**
+   * The feature id for the '<em><b>Ancestor Scope</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GCOMPARISON__ANCESTOR_SCOPE = GIDENTIFIED_FEATURE_COUNT + 0;
+
+  /**
+   * The feature id for the '<em><b>Reference Scope</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GCOMPARISON__REFERENCE_SCOPE = GIDENTIFIED_FEATURE_COUNT + 1;
+
+  /**
+   * The feature id for the '<em><b>Target Scope</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GCOMPARISON__TARGET_SCOPE = GIDENTIFIED_FEATURE_COUNT + 2;
+
+  /**
+   * The feature id for the '<em><b>Last Match Policy</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GCOMPARISON__LAST_MATCH_POLICY = GIDENTIFIED_FEATURE_COUNT + 3;
+
+  /**
+   * The feature id for the '<em><b>Last Diff Policy</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GCOMPARISON__LAST_DIFF_POLICY = GIDENTIFIED_FEATURE_COUNT + 4;
+
+  /**
+   * The feature id for the '<em><b>Last Merge Policy</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GCOMPARISON__LAST_MERGE_POLICY = GIDENTIFIED_FEATURE_COUNT + 5;
+
+  /**
+   * The feature id for the '<em><b>Mapping</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GCOMPARISON__MAPPING = GIDENTIFIED_FEATURE_COUNT + 6;
+
+  /**
+   * The number of structural features of the '<em>GComparison</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GCOMPARISON_FEATURE_COUNT = GIDENTIFIED_FEATURE_COUNT + 7;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement <em>GComparison Element</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGComparisonElement()
+   * @generated
+   */
+  int GCOMPARISON_ELEMENT = 2;
+
+  /**
+   * The number of structural features of the '<em>GComparison Element</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GCOMPARISON_ELEMENT_FEATURE_COUNT = 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMappingImpl <em>GMapping</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMappingImpl
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGMapping()
+   * @generated
+   */
+  int GMAPPING = 3;
+
+  /**
+   * The feature id for the '<em><b>Id</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMAPPING__ID = GIDENTIFIED__ID;
+
+  /**
+   * The feature id for the '<em><b>Modifiable Contents</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMAPPING__MODIFIABLE_CONTENTS = GIDENTIFIED_FEATURE_COUNT + 0;
+
+  /**
+   * The feature id for the '<em><b>Reference Completed Matches</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMAPPING__REFERENCE_COMPLETED_MATCHES = GIDENTIFIED_FEATURE_COUNT + 1;
+
+  /**
+   * The feature id for the '<em><b>Target Completed Matches</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMAPPING__TARGET_COMPLETED_MATCHES = GIDENTIFIED_FEATURE_COUNT + 2;
+
+  /**
+   * The number of structural features of the '<em>GMapping</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMAPPING_FEATURE_COUNT = GIDENTIFIED_FEATURE_COUNT + 3;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMatchImpl <em>GMatch</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMatchImpl
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGMatch()
+   * @generated
+   */
+  int GMATCH = 4;
+
+  /**
+   * The feature id for the '<em><b>Id</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMATCH__ID = GIDENTIFIED__ID;
+
+  /**
+   * The feature id for the '<em><b>Match ID</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMATCH__MATCH_ID = GIDENTIFIED_FEATURE_COUNT + 0;
+
+  /**
+   * The feature id for the '<em><b>Modifiable Related Differences</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMATCH__MODIFIABLE_RELATED_DIFFERENCES = GIDENTIFIED_FEATURE_COUNT + 1;
+
+  /**
+   * The feature id for the '<em><b>Element Presence Difference</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMATCH__ELEMENT_PRESENCE_DIFFERENCE = GIDENTIFIED_FEATURE_COUNT + 2;
+
+  /**
+   * The feature id for the '<em><b>Reference Ownership Difference</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMATCH__REFERENCE_OWNERSHIP_DIFFERENCE = GIDENTIFIED_FEATURE_COUNT + 3;
+
+  /**
+   * The feature id for the '<em><b>Target Ownership Difference</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMATCH__TARGET_OWNERSHIP_DIFFERENCE = GIDENTIFIED_FEATURE_COUNT + 4;
+
+  /**
+   * The number of structural features of the '<em>GMatch</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMATCH_FEATURE_COUNT = GIDENTIFIED_FEATURE_COUNT + 5;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl <em>GMergeable Difference</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGMergeableDifference()
+   * @generated
+   */
+  int GMERGEABLE_DIFFERENCE = 5;
+
+  /**
+   * The feature id for the '<em><b>Id</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMERGEABLE_DIFFERENCE__ID = GIDENTIFIED__ID;
+
+  /**
+   * The feature id for the '<em><b>Aligned With Ancestor</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR = GIDENTIFIED_FEATURE_COUNT
+      + 0;
+
+  /**
+   * The feature id for the '<em><b>Conflicting</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMERGEABLE_DIFFERENCE__CONFLICTING = GIDENTIFIED_FEATURE_COUNT + 1;
+
+  /**
+   * The feature id for the '<em><b>Ignored</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMERGEABLE_DIFFERENCE__IGNORED = GIDENTIFIED_FEATURE_COUNT + 2;
+
+  /**
+   * The feature id for the '<em><b>Merge Destination</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMERGEABLE_DIFFERENCE__MERGE_DESTINATION = GIDENTIFIED_FEATURE_COUNT + 3;
+
+  /**
+   * The feature id for the '<em><b>Possible Merge Destinations</b></em>' attribute list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS = GIDENTIFIED_FEATURE_COUNT
+      + 4;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET = GIDENTIFIED_FEATURE_COUNT
+      + 5;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE = GIDENTIFIED_FEATURE_COUNT
+      + 6;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET = GIDENTIFIED_FEATURE_COUNT
+      + 7;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE = GIDENTIFIED_FEATURE_COUNT
+      + 8;
+
+  /**
+   * The number of structural features of the '<em>GMergeable Difference</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GMERGEABLE_DIFFERENCE_FEATURE_COUNT = GIDENTIFIED_FEATURE_COUNT + 9;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementRelativePresenceImpl <em>GElement Relative Presence</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementRelativePresenceImpl
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGElementRelativePresence()
+   * @generated
+   */
+  int GELEMENT_RELATIVE_PRESENCE = 6;
+
+  /**
+   * The feature id for the '<em><b>Id</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__ID = GMERGEABLE_DIFFERENCE__ID;
+
+  /**
+   * The feature id for the '<em><b>Aligned With Ancestor</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__ALIGNED_WITH_ANCESTOR = GMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR;
+
+  /**
+   * The feature id for the '<em><b>Conflicting</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__CONFLICTING = GMERGEABLE_DIFFERENCE__CONFLICTING;
+
+  /**
+   * The feature id for the '<em><b>Ignored</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__IGNORED = GMERGEABLE_DIFFERENCE__IGNORED;
+
+  /**
+   * The feature id for the '<em><b>Merge Destination</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__MERGE_DESTINATION = GMERGEABLE_DIFFERENCE__MERGE_DESTINATION;
+
+  /**
+   * The feature id for the '<em><b>Possible Merge Destinations</b></em>' attribute list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__POSSIBLE_MERGE_DESTINATIONS = GMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET = GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE = GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET = GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE = GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE;
+
+  /**
+   * The feature id for the '<em><b>Element Match</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH = GMERGEABLE_DIFFERENCE_FEATURE_COUNT
+      + 0;
+
+  /**
+   * The feature id for the '<em><b>Presence Role</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE = GMERGEABLE_DIFFERENCE_FEATURE_COUNT
+      + 1;
+
+  /**
+   * The number of structural features of the '<em>GElement Relative Presence</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_RELATIVE_PRESENCE_FEATURE_COUNT = GMERGEABLE_DIFFERENCE_FEATURE_COUNT
+      + 2;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementPresenceImpl <em>GElement Presence</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementPresenceImpl
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGElementPresence()
+   * @generated
+   */
+  int GELEMENT_PRESENCE = 7;
+
+  /**
+   * The feature id for the '<em><b>Id</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__ID = GELEMENT_RELATIVE_PRESENCE__ID;
+
+  /**
+   * The feature id for the '<em><b>Aligned With Ancestor</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__ALIGNED_WITH_ANCESTOR = GELEMENT_RELATIVE_PRESENCE__ALIGNED_WITH_ANCESTOR;
+
+  /**
+   * The feature id for the '<em><b>Conflicting</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__CONFLICTING = GELEMENT_RELATIVE_PRESENCE__CONFLICTING;
+
+  /**
+   * The feature id for the '<em><b>Ignored</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__IGNORED = GELEMENT_RELATIVE_PRESENCE__IGNORED;
+
+  /**
+   * The feature id for the '<em><b>Merge Destination</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__MERGE_DESTINATION = GELEMENT_RELATIVE_PRESENCE__MERGE_DESTINATION;
+
+  /**
+   * The feature id for the '<em><b>Possible Merge Destinations</b></em>' attribute list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__POSSIBLE_MERGE_DESTINATIONS = GELEMENT_RELATIVE_PRESENCE__POSSIBLE_MERGE_DESTINATIONS;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET = GELEMENT_RELATIVE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE = GELEMENT_RELATIVE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET = GELEMENT_RELATIVE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE = GELEMENT_RELATIVE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE;
+
+  /**
+   * The feature id for the '<em><b>Element Match</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__ELEMENT_MATCH = GELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH;
+
+  /**
+   * The feature id for the '<em><b>Presence Role</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__PRESENCE_ROLE = GELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE;
+
+  /**
+   * The feature id for the '<em><b>Owner Match</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE__OWNER_MATCH = GELEMENT_RELATIVE_PRESENCE_FEATURE_COUNT
+      + 0;
+
+  /**
+   * The number of structural features of the '<em>GElement Presence</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GELEMENT_PRESENCE_FEATURE_COUNT = GELEMENT_RELATIVE_PRESENCE_FEATURE_COUNT
+      + 1;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl <em>GValue Presence</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGValuePresence()
+   * @generated
+   */
+  int GVALUE_PRESENCE = 8;
+
+  /**
+   * The feature id for the '<em><b>Id</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__ID = GELEMENT_RELATIVE_PRESENCE__ID;
+
+  /**
+   * The feature id for the '<em><b>Aligned With Ancestor</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__ALIGNED_WITH_ANCESTOR = GELEMENT_RELATIVE_PRESENCE__ALIGNED_WITH_ANCESTOR;
+
+  /**
+   * The feature id for the '<em><b>Conflicting</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__CONFLICTING = GELEMENT_RELATIVE_PRESENCE__CONFLICTING;
+
+  /**
+   * The feature id for the '<em><b>Ignored</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__IGNORED = GELEMENT_RELATIVE_PRESENCE__IGNORED;
+
+  /**
+   * The feature id for the '<em><b>Merge Destination</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__MERGE_DESTINATION = GELEMENT_RELATIVE_PRESENCE__MERGE_DESTINATION;
+
+  /**
+   * The feature id for the '<em><b>Possible Merge Destinations</b></em>' attribute list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__POSSIBLE_MERGE_DESTINATIONS = GELEMENT_RELATIVE_PRESENCE__POSSIBLE_MERGE_DESTINATIONS;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET = GELEMENT_RELATIVE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE = GELEMENT_RELATIVE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET = GELEMENT_RELATIVE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE = GELEMENT_RELATIVE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE;
+
+  /**
+   * The feature id for the '<em><b>Element Match</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__ELEMENT_MATCH = GELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH;
+
+  /**
+   * The feature id for the '<em><b>Presence Role</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__PRESENCE_ROLE = GELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE;
+
+  /**
+   * The feature id for the '<em><b>Order</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE__ORDER = GELEMENT_RELATIVE_PRESENCE_FEATURE_COUNT + 0;
+
+  /**
+   * The number of structural features of the '<em>GValue Presence</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GVALUE_PRESENCE_FEATURE_COUNT = GELEMENT_RELATIVE_PRESENCE_FEATURE_COUNT
+      + 1;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GAttributeValuePresenceImpl <em>GAttribute Value Presence</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GAttributeValuePresenceImpl
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGAttributeValuePresence()
+   * @generated
+   */
+  int GATTRIBUTE_VALUE_PRESENCE = 9;
+
+  /**
+   * The feature id for the '<em><b>Id</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__ID = GVALUE_PRESENCE__ID;
+
+  /**
+   * The feature id for the '<em><b>Aligned With Ancestor</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__ALIGNED_WITH_ANCESTOR = GVALUE_PRESENCE__ALIGNED_WITH_ANCESTOR;
+
+  /**
+   * The feature id for the '<em><b>Conflicting</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__CONFLICTING = GVALUE_PRESENCE__CONFLICTING;
+
+  /**
+   * The feature id for the '<em><b>Ignored</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__IGNORED = GVALUE_PRESENCE__IGNORED;
+
+  /**
+   * The feature id for the '<em><b>Merge Destination</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__MERGE_DESTINATION = GVALUE_PRESENCE__MERGE_DESTINATION;
+
+  /**
+   * The feature id for the '<em><b>Possible Merge Destinations</b></em>' attribute list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__POSSIBLE_MERGE_DESTINATIONS = GVALUE_PRESENCE__POSSIBLE_MERGE_DESTINATIONS;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET = GVALUE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE = GVALUE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET = GVALUE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE = GVALUE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE;
+
+  /**
+   * The feature id for the '<em><b>Element Match</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__ELEMENT_MATCH = GVALUE_PRESENCE__ELEMENT_MATCH;
+
+  /**
+   * The feature id for the '<em><b>Presence Role</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__PRESENCE_ROLE = GVALUE_PRESENCE__PRESENCE_ROLE;
+
+  /**
+   * The feature id for the '<em><b>Order</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE__ORDER = GVALUE_PRESENCE__ORDER;
+
+  /**
+   * The number of structural features of the '<em>GAttribute Value Presence</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GATTRIBUTE_VALUE_PRESENCE_FEATURE_COUNT = GVALUE_PRESENCE_FEATURE_COUNT
+      + 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GReferenceValuePresenceImpl <em>GReference Value Presence</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GReferenceValuePresenceImpl
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGReferenceValuePresence()
+   * @generated
+   */
+  int GREFERENCE_VALUE_PRESENCE = 10;
+
+  /**
+   * The feature id for the '<em><b>Id</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__ID = GVALUE_PRESENCE__ID;
+
+  /**
+   * The feature id for the '<em><b>Aligned With Ancestor</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__ALIGNED_WITH_ANCESTOR = GVALUE_PRESENCE__ALIGNED_WITH_ANCESTOR;
+
+  /**
+   * The feature id for the '<em><b>Conflicting</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__CONFLICTING = GVALUE_PRESENCE__CONFLICTING;
+
+  /**
+   * The feature id for the '<em><b>Ignored</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__IGNORED = GVALUE_PRESENCE__IGNORED;
+
+  /**
+   * The feature id for the '<em><b>Merge Destination</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__MERGE_DESTINATION = GVALUE_PRESENCE__MERGE_DESTINATION;
+
+  /**
+   * The feature id for the '<em><b>Possible Merge Destinations</b></em>' attribute list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__POSSIBLE_MERGE_DESTINATIONS = GVALUE_PRESENCE__POSSIBLE_MERGE_DESTINATIONS;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET = GVALUE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET;
+
+  /**
+   * The feature id for the '<em><b>Explicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE = GVALUE_PRESENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Target</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET = GVALUE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET;
+
+  /**
+   * The feature id for the '<em><b>Implicit Dependencies For Reference</b></em>' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE = GVALUE_PRESENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE;
+
+  /**
+   * The feature id for the '<em><b>Element Match</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__ELEMENT_MATCH = GVALUE_PRESENCE__ELEMENT_MATCH;
+
+  /**
+   * The feature id for the '<em><b>Presence Role</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__PRESENCE_ROLE = GVALUE_PRESENCE__PRESENCE_ROLE;
+
+  /**
+   * The feature id for the '<em><b>Order</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__ORDER = GVALUE_PRESENCE__ORDER;
+
+  /**
+   * The feature id for the '<em><b>Value Match</b></em>' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE__VALUE_MATCH = GVALUE_PRESENCE_FEATURE_COUNT
+      + 0;
+
+  /**
+   * The number of structural features of the '<em>GReference Value Presence</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GREFERENCE_VALUE_PRESENCE_FEATURE_COUNT = GVALUE_PRESENCE_FEATURE_COUNT
+      + 1;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.IComparison.Editable <em>IEditable Comparison</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison.Editable
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIEditableComparison()
+   * @generated
+   */
+  int IEDITABLE_COMPARISON = 12;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.IMapping.Editable <em>IEditable Mapping</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping.Editable
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIEditableMapping()
+   * @generated
+   */
+  int IEDITABLE_MAPPING = 14;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.IMatch.Editable <em>IEditable Match</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch.Editable
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIEditableMatch()
+   * @generated
+   */
+  int IEDITABLE_MATCH = 16;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable <em>IEditable Mergeable Difference</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIEditableMergeableDifference()
+   * @generated
+   */
+  int IEDITABLE_MERGEABLE_DIFFERENCE = 18;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.IComparison <em>IComparison</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIComparison()
+   * @generated
+   */
+  int ICOMPARISON = 11;
+
+  /**
+   * The number of structural features of the '<em>IComparison</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ICOMPARISON_FEATURE_COUNT = 0;
+
+  /**
+   * The number of structural features of the '<em>IEditable Comparison</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IEDITABLE_COMPARISON_FEATURE_COUNT = 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.IMapping <em>IMapping</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIMapping()
+   * @generated
+   */
+  int IMAPPING = 13;
+
+  /**
+   * The number of structural features of the '<em>IMapping</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IMAPPING_FEATURE_COUNT = 0;
+
+  /**
+   * The number of structural features of the '<em>IEditable Mapping</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IEDITABLE_MAPPING_FEATURE_COUNT = 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.IMatch <em>IMatch</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIMatch()
+   * @generated
+   */
+  int IMATCH = 15;
+
+  /**
+   * The number of structural features of the '<em>IMatch</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IMATCH_FEATURE_COUNT = 0;
+
+  /**
+   * The number of structural features of the '<em>IEditable Match</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IEDITABLE_MATCH_FEATURE_COUNT = 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference <em>IMergeable Difference</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIMergeableDifference()
+   * @generated
+   */
+  int IMERGEABLE_DIFFERENCE = 17;
+
+  /**
+   * The number of structural features of the '<em>IMergeable Difference</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IMERGEABLE_DIFFERENCE_FEATURE_COUNT = 0;
+
+  /**
+   * The number of structural features of the '<em>IEditable Mergeable Difference</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IEDITABLE_MERGEABLE_DIFFERENCE_FEATURE_COUNT = 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativePresence <em>IElement Relative Presence</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativePresence
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIElementRelativePresence()
+   * @generated
+   */
+  int IELEMENT_RELATIVE_PRESENCE = 19;
+
+  /**
+   * The number of structural features of the '<em>IElement Relative Presence</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IELEMENT_RELATIVE_PRESENCE_FEATURE_COUNT = 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence <em>IElement Presence</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIElementPresence()
+   * @generated
+   */
+  int IELEMENT_PRESENCE = 20;
+
+  /**
+   * The number of structural features of the '<em>IElement Presence</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IELEMENT_PRESENCE_FEATURE_COUNT = 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence <em>IValue Presence</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIValuePresence()
+   * @generated
+   */
+  int IVALUE_PRESENCE = 21;
+
+  /**
+   * The number of structural features of the '<em>IValue Presence</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IVALUE_PRESENCE_FEATURE_COUNT = 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence <em>IAttribute Value Presence</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIAttributeValuePresence()
+   * @generated
+   */
+  int IATTRIBUTE_VALUE_PRESENCE = 22;
+
+  /**
+   * The number of structural features of the '<em>IAttribute Value Presence</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IATTRIBUTE_VALUE_PRESENCE_FEATURE_COUNT = 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence <em>IReference Value Presence</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIReferenceValuePresence()
+   * @generated
+   */
+  int IREFERENCE_VALUE_PRESENCE = 23;
+
+  /**
+   * The number of structural features of the '<em>IReference Value Presence</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IREFERENCE_VALUE_PRESENCE_FEATURE_COUNT = 0;
+
+  /**
+   * The meta object id for the '<em>IEditable Tree Data Scope</em>' data type.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIEditableTreeDataScope()
+   * @generated
+   */
+  int IEDITABLE_TREE_DATA_SCOPE = 24;
+
+  /**
+   * The meta object id for the '<em>IMatch Policy</em>' data type.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatchPolicy
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIMatchPolicy()
+   * @generated
+   */
+  int IMATCH_POLICY = 25;
+
+  /**
+   * The meta object id for the '<em>IDiff Policy</em>' data type.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.IDiffPolicy
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIDiffPolicy()
+   * @generated
+   */
+  int IDIFF_POLICY = 26;
+
+  /**
+   * The meta object id for the '<em>IMerge Policy</em>' data type.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.IMergePolicy
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIMergePolicy()
+   * @generated
+   */
+  int IMERGE_POLICY = 27;
+
+  /**
+   * The meta object id for the '<em>Role</em>' data type.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.diffmerge.generic.api.Role
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getRole()
+   * @generated
+   */
+  int ROLE = 28;
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GIdentified <em>GIdentified</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>GIdentified</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GIdentified
+   * @generated
+   */
+  EClass getGIdentified();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GIdentified#getId <em>Id</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Id</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GIdentified#getId()
+   * @see #getGIdentified()
+   * @generated
+   */
+  EAttribute getGIdentified_Id();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison <em>GComparison</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>GComparison</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison
+   * @generated
+   */
+  EClass getGComparison();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getAncestorScope <em>Ancestor Scope</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Ancestor Scope</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getAncestorScope()
+   * @see #getGComparison()
+   * @generated
+   */
+  EAttribute getGComparison_AncestorScope();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getReferenceScope <em>Reference Scope</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Reference Scope</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getReferenceScope()
+   * @see #getGComparison()
+   * @generated
+   */
+  EAttribute getGComparison_ReferenceScope();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getTargetScope <em>Target Scope</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Target Scope</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getTargetScope()
+   * @see #getGComparison()
+   * @generated
+   */
+  EAttribute getGComparison_TargetScope();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastMatchPolicy <em>Last Match Policy</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Last Match Policy</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastMatchPolicy()
+   * @see #getGComparison()
+   * @generated
+   */
+  EAttribute getGComparison_LastMatchPolicy();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastDiffPolicy <em>Last Diff Policy</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Last Diff Policy</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastDiffPolicy()
+   * @see #getGComparison()
+   * @generated
+   */
+  EAttribute getGComparison_LastDiffPolicy();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastMergePolicy <em>Last Merge Policy</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Last Merge Policy</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getLastMergePolicy()
+   * @see #getGComparison()
+   * @generated
+   */
+  EAttribute getGComparison_LastMergePolicy();
+
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getMapping <em>Mapping</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Mapping</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison#getMapping()
+   * @see #getGComparison()
+   * @generated
+   */
+  EReference getGComparison_Mapping();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement <em>GComparison Element</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>GComparison Element</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement
+   * @generated
+   */
+  EClass getGComparisonElement();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping <em>GMapping</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>GMapping</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping
+   * @generated
+   */
+  EClass getGMapping();
+
+  /**
+   * Returns the meta object for the containment reference list '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping#getModifiableContents <em>Modifiable Contents</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference list '<em>Modifiable Contents</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping#getModifiableContents()
+   * @see #getGMapping()
+   * @generated
+   */
+  EReference getGMapping_ModifiableContents();
+
+  /**
+   * Returns the meta object for the reference list '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping#getReferenceCompletedMatches <em>Reference Completed Matches</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference list '<em>Reference Completed Matches</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping#getReferenceCompletedMatches()
+   * @see #getGMapping()
+   * @generated
+   */
+  EReference getGMapping_ReferenceCompletedMatches();
+
+  /**
+   * Returns the meta object for the reference list '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping#getTargetCompletedMatches <em>Target Completed Matches</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference list '<em>Target Completed Matches</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping#getTargetCompletedMatches()
+   * @see #getGMapping()
+   * @generated
+   */
+  EReference getGMapping_TargetCompletedMatches();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch <em>GMatch</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>GMatch</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch
+   * @generated
+   */
+  EClass getGMatch();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getMatchID <em>Match ID</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Match ID</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getMatchID()
+   * @see #getGMatch()
+   * @generated
+   */
+  EAttribute getGMatch_MatchID();
+
+  /**
+   * Returns the meta object for the containment reference list '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getModifiableRelatedDifferences <em>Modifiable Related Differences</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference list '<em>Modifiable Related Differences</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getModifiableRelatedDifferences()
+   * @see #getGMatch()
+   * @generated
+   */
+  EReference getGMatch_ModifiableRelatedDifferences();
+
+  /**
+   * Returns the meta object for the reference '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getElementPresenceDifference <em>Element Presence Difference</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference '<em>Element Presence Difference</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getElementPresenceDifference()
+   * @see #getGMatch()
+   * @generated
+   */
+  EReference getGMatch_ElementPresenceDifference();
+
+  /**
+   * Returns the meta object for the reference '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getReferenceOwnershipDifference <em>Reference Ownership Difference</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference '<em>Reference Ownership Difference</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getReferenceOwnershipDifference()
+   * @see #getGMatch()
+   * @generated
+   */
+  EReference getGMatch_ReferenceOwnershipDifference();
+
+  /**
+   * Returns the meta object for the reference '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getTargetOwnershipDifference <em>Target Ownership Difference</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference '<em>Target Ownership Difference</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getTargetOwnershipDifference()
+   * @see #getGMatch()
+   * @generated
+   */
+  EReference getGMatch_TargetOwnershipDifference();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference <em>GMergeable Difference</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>GMergeable Difference</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference
+   * @generated
+   */
+  EClass getGMergeableDifference();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isAlignedWithAncestor <em>Aligned With Ancestor</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Aligned With Ancestor</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isAlignedWithAncestor()
+   * @see #getGMergeableDifference()
+   * @generated
+   */
+  EAttribute getGMergeableDifference_AlignedWithAncestor();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isConflicting <em>Conflicting</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Conflicting</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isConflicting()
+   * @see #getGMergeableDifference()
+   * @generated
+   */
+  EAttribute getGMergeableDifference_Conflicting();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isIgnored <em>Ignored</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Ignored</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#isIgnored()
+   * @see #getGMergeableDifference()
+   * @generated
+   */
+  EAttribute getGMergeableDifference_Ignored();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getMergeDestination <em>Merge Destination</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Merge Destination</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getMergeDestination()
+   * @see #getGMergeableDifference()
+   * @generated
+   */
+  EAttribute getGMergeableDifference_MergeDestination();
+
+  /**
+   * Returns the meta object for the attribute list '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getPossibleMergeDestinations <em>Possible Merge Destinations</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute list '<em>Possible Merge Destinations</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getPossibleMergeDestinations()
+   * @see #getGMergeableDifference()
+   * @generated
+   */
+  EAttribute getGMergeableDifference_PossibleMergeDestinations();
+
+  /**
+   * Returns the meta object for the reference list '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getExplicitDependenciesForTarget <em>Explicit Dependencies For Target</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference list '<em>Explicit Dependencies For Target</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getExplicitDependenciesForTarget()
+   * @see #getGMergeableDifference()
+   * @generated
+   */
+  EReference getGMergeableDifference_ExplicitDependenciesForTarget();
+
+  /**
+   * Returns the meta object for the reference list '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getExplicitDependenciesForReference <em>Explicit Dependencies For Reference</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference list '<em>Explicit Dependencies For Reference</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getExplicitDependenciesForReference()
+   * @see #getGMergeableDifference()
+   * @generated
+   */
+  EReference getGMergeableDifference_ExplicitDependenciesForReference();
+
+  /**
+   * Returns the meta object for the reference list '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getImplicitDependenciesForTarget <em>Implicit Dependencies For Target</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference list '<em>Implicit Dependencies For Target</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getImplicitDependenciesForTarget()
+   * @see #getGMergeableDifference()
+   * @generated
+   */
+  EReference getGMergeableDifference_ImplicitDependenciesForTarget();
+
+  /**
+   * Returns the meta object for the reference list '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getImplicitDependenciesForReference <em>Implicit Dependencies For Reference</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference list '<em>Implicit Dependencies For Reference</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference#getImplicitDependenciesForReference()
+   * @see #getGMergeableDifference()
+   * @generated
+   */
+  EReference getGMergeableDifference_ImplicitDependenciesForReference();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence <em>GElement Relative Presence</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>GElement Relative Presence</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence
+   * @generated
+   */
+  EClass getGElementRelativePresence();
+
+  /**
+   * Returns the meta object for the reference '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence#getElementMatch <em>Element Match</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference '<em>Element Match</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence#getElementMatch()
+   * @see #getGElementRelativePresence()
+   * @generated
+   */
+  EReference getGElementRelativePresence_ElementMatch();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence#getPresenceRole <em>Presence Role</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Presence Role</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence#getPresenceRole()
+   * @see #getGElementRelativePresence()
+   * @generated
+   */
+  EAttribute getGElementRelativePresence_PresenceRole();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GElementPresence <em>GElement Presence</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>GElement Presence</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GElementPresence
+   * @generated
+   */
+  EClass getGElementPresence();
+
+  /**
+   * Returns the meta object for the reference '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GElementPresence#getOwnerMatch <em>Owner Match</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference '<em>Owner Match</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GElementPresence#getOwnerMatch()
+   * @see #getGElementPresence()
+   * @generated
+   */
+  EReference getGElementPresence_OwnerMatch();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GValuePresence <em>GValue Presence</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>GValue Presence</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GValuePresence
+   * @generated
+   */
+  EClass getGValuePresence();
+
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GValuePresence#isOrder <em>Order</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Order</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GValuePresence#isOrder()
+   * @see #getGValuePresence()
+   * @generated
+   */
+  EAttribute getGValuePresence_Order();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GAttributeValuePresence <em>GAttribute Value Presence</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>GAttribute Value Presence</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GAttributeValuePresence
+   * @generated
+   */
+  EClass getGAttributeValuePresence();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GReferenceValuePresence <em>GReference Value Presence</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>GReference Value Presence</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GReferenceValuePresence
+   * @generated
+   */
+  EClass getGReferenceValuePresence();
+
+  /**
+   * Returns the meta object for the reference '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GReferenceValuePresence#getValueMatch <em>Value Match</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the reference '<em>Value Match</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GReferenceValuePresence#getValueMatch()
+   * @see #getGReferenceValuePresence()
+   * @generated
+   */
+  EReference getGReferenceValuePresence_ValueMatch();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.IComparison <em>IComparison</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IComparison</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.IComparison" typeParameters="E"
+   * @generated
+   */
+  EClass getIComparison();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.IComparison.Editable <em>IEditable Comparison</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IEditable Comparison</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison.Editable
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.IComparison.Editable" typeParameters="E"
+   * @generated
+   */
+  EClass getIEditableComparison();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.IMapping <em>IMapping</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IMapping</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.IMapping" typeParameters="E"
+   * @generated
+   */
+  EClass getIMapping();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.IMapping.Editable <em>IEditable Mapping</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IEditable Mapping</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping.Editable
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.IMapping.Editable" typeParameters="E"
+   * @generated
+   */
+  EClass getIEditableMapping();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.IMatch <em>IMatch</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IMatch</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.IMatch" typeParameters="E"
+   * @generated
+   */
+  EClass getIMatch();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.IMatch.Editable <em>IEditable Match</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IEditable Match</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch.Editable
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.IMatch.Editable" typeParameters="E"
+   * @generated
+   */
+  EClass getIEditableMatch();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference <em>IMergeable Difference</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IMergeable Difference</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference" typeParameters="E"
+   * @generated
+   */
+  EClass getIMergeableDifference();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable <em>IEditable Mergeable Difference</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IEditable Mergeable Difference</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable" typeParameters="E"
+   * @generated
+   */
+  EClass getIEditableMergeableDifference();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativePresence <em>IElement Relative Presence</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IElement Relative Presence</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativePresence
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativePresence" typeParameters="E"
+   * @generated
+   */
+  EClass getIElementRelativePresence();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence <em>IElement Presence</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IElement Presence</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence" typeParameters="E"
+   * @generated
+   */
+  EClass getIElementPresence();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence <em>IValue Presence</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IValue Presence</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence" typeParameters="E"
+   * @generated
+   */
+  EClass getIValuePresence();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence <em>IAttribute Value Presence</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IAttribute Value Presence</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence" typeParameters="E"
+   * @generated
+   */
+  EClass getIAttributeValuePresence();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence <em>IReference Value Presence</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>IReference Value Presence</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence" typeParameters="E"
+   * @generated
+   */
+  EClass getIReferenceValuePresence();
+
+  /**
+   * Returns the meta object for data type '{@link org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope <em>IEditable Tree Data Scope</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for data type '<em>IEditable Tree Data Scope</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope" typeParameters="E"
+   * @generated
+   */
+  EDataType getIEditableTreeDataScope();
+
+  /**
+   * Returns the meta object for data type '{@link org.eclipse.emf.diffmerge.generic.api.IMatchPolicy <em>IMatch Policy</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for data type '<em>IMatch Policy</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatchPolicy
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.IMatchPolicy" typeParameters="E"
+   * @generated
+   */
+  EDataType getIMatchPolicy();
+
+  /**
+   * Returns the meta object for data type '{@link org.eclipse.emf.diffmerge.generic.api.IDiffPolicy <em>IDiff Policy</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for data type '<em>IDiff Policy</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.IDiffPolicy
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.IDiffPolicy" typeParameters="E"
+   * @generated
+   */
+  EDataType getIDiffPolicy();
+
+  /**
+   * Returns the meta object for data type '{@link org.eclipse.emf.diffmerge.generic.api.IMergePolicy <em>IMerge Policy</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for data type '<em>IMerge Policy</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.IMergePolicy
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.IMergePolicy" typeParameters="E"
+   * @generated
+   */
+  EDataType getIMergePolicy();
+
+  /**
+   * Returns the meta object for data type '{@link org.eclipse.emf.diffmerge.generic.api.Role <em>Role</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for data type '<em>Role</em>'.
+   * @see org.eclipse.emf.diffmerge.generic.api.Role
+   * @model instanceClass="org.eclipse.emf.diffmerge.generic.api.Role"
+   * @generated
+   */
+  EDataType getRole();
+
+  /**
+   * 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
+   */
+  GdiffdataFactory getGdiffdataFactory();
+
+  /**
+   * <!-- 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
+   */
+  interface Literals {
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GIdentifiedImpl <em>GIdentified</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GIdentifiedImpl
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGIdentified()
+     * @generated
+     */
+    EClass GIDENTIFIED = eINSTANCE.getGIdentified();
+
+    /**
+     * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GIDENTIFIED__ID = eINSTANCE.getGIdentified_Id();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GComparisonImpl <em>GComparison</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GComparisonImpl
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGComparison()
+     * @generated
+     */
+    EClass GCOMPARISON = eINSTANCE.getGComparison();
+
+    /**
+     * The meta object literal for the '<em><b>Ancestor Scope</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GCOMPARISON__ANCESTOR_SCOPE = eINSTANCE
+        .getGComparison_AncestorScope();
+
+    /**
+     * The meta object literal for the '<em><b>Reference Scope</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GCOMPARISON__REFERENCE_SCOPE = eINSTANCE
+        .getGComparison_ReferenceScope();
+
+    /**
+     * The meta object literal for the '<em><b>Target Scope</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GCOMPARISON__TARGET_SCOPE = eINSTANCE
+        .getGComparison_TargetScope();
+
+    /**
+     * The meta object literal for the '<em><b>Last Match Policy</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GCOMPARISON__LAST_MATCH_POLICY = eINSTANCE
+        .getGComparison_LastMatchPolicy();
+
+    /**
+     * The meta object literal for the '<em><b>Last Diff Policy</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GCOMPARISON__LAST_DIFF_POLICY = eINSTANCE
+        .getGComparison_LastDiffPolicy();
+
+    /**
+     * The meta object literal for the '<em><b>Last Merge Policy</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GCOMPARISON__LAST_MERGE_POLICY = eINSTANCE
+        .getGComparison_LastMergePolicy();
+
+    /**
+     * The meta object literal for the '<em><b>Mapping</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GCOMPARISON__MAPPING = eINSTANCE.getGComparison_Mapping();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement <em>GComparison Element</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGComparisonElement()
+     * @generated
+     */
+    EClass GCOMPARISON_ELEMENT = eINSTANCE.getGComparisonElement();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMappingImpl <em>GMapping</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMappingImpl
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGMapping()
+     * @generated
+     */
+    EClass GMAPPING = eINSTANCE.getGMapping();
+
+    /**
+     * The meta object literal for the '<em><b>Modifiable Contents</b></em>' containment reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GMAPPING__MODIFIABLE_CONTENTS = eINSTANCE
+        .getGMapping_ModifiableContents();
+
+    /**
+     * The meta object literal for the '<em><b>Reference Completed Matches</b></em>' reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GMAPPING__REFERENCE_COMPLETED_MATCHES = eINSTANCE
+        .getGMapping_ReferenceCompletedMatches();
+
+    /**
+     * The meta object literal for the '<em><b>Target Completed Matches</b></em>' reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GMAPPING__TARGET_COMPLETED_MATCHES = eINSTANCE
+        .getGMapping_TargetCompletedMatches();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMatchImpl <em>GMatch</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMatchImpl
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGMatch()
+     * @generated
+     */
+    EClass GMATCH = eINSTANCE.getGMatch();
+
+    /**
+     * The meta object literal for the '<em><b>Match ID</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GMATCH__MATCH_ID = eINSTANCE.getGMatch_MatchID();
+
+    /**
+     * The meta object literal for the '<em><b>Modifiable Related Differences</b></em>' containment reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GMATCH__MODIFIABLE_RELATED_DIFFERENCES = eINSTANCE
+        .getGMatch_ModifiableRelatedDifferences();
+
+    /**
+     * The meta object literal for the '<em><b>Element Presence Difference</b></em>' reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GMATCH__ELEMENT_PRESENCE_DIFFERENCE = eINSTANCE
+        .getGMatch_ElementPresenceDifference();
+
+    /**
+     * The meta object literal for the '<em><b>Reference Ownership Difference</b></em>' reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GMATCH__REFERENCE_OWNERSHIP_DIFFERENCE = eINSTANCE
+        .getGMatch_ReferenceOwnershipDifference();
+
+    /**
+     * The meta object literal for the '<em><b>Target Ownership Difference</b></em>' reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GMATCH__TARGET_OWNERSHIP_DIFFERENCE = eINSTANCE
+        .getGMatch_TargetOwnershipDifference();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl <em>GMergeable Difference</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGMergeableDifference()
+     * @generated
+     */
+    EClass GMERGEABLE_DIFFERENCE = eINSTANCE.getGMergeableDifference();
+
+    /**
+     * The meta object literal for the '<em><b>Aligned With Ancestor</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR = eINSTANCE
+        .getGMergeableDifference_AlignedWithAncestor();
+
+    /**
+     * The meta object literal for the '<em><b>Conflicting</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GMERGEABLE_DIFFERENCE__CONFLICTING = eINSTANCE
+        .getGMergeableDifference_Conflicting();
+
+    /**
+     * The meta object literal for the '<em><b>Ignored</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GMERGEABLE_DIFFERENCE__IGNORED = eINSTANCE
+        .getGMergeableDifference_Ignored();
+
+    /**
+     * The meta object literal for the '<em><b>Merge Destination</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GMERGEABLE_DIFFERENCE__MERGE_DESTINATION = eINSTANCE
+        .getGMergeableDifference_MergeDestination();
+
+    /**
+     * The meta object literal for the '<em><b>Possible Merge Destinations</b></em>' attribute list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS = eINSTANCE
+        .getGMergeableDifference_PossibleMergeDestinations();
+
+    /**
+     * The meta object literal for the '<em><b>Explicit Dependencies For Target</b></em>' reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET = eINSTANCE
+        .getGMergeableDifference_ExplicitDependenciesForTarget();
+
+    /**
+     * The meta object literal for the '<em><b>Explicit Dependencies For Reference</b></em>' reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE = eINSTANCE
+        .getGMergeableDifference_ExplicitDependenciesForReference();
+
+    /**
+     * The meta object literal for the '<em><b>Implicit Dependencies For Target</b></em>' reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET = eINSTANCE
+        .getGMergeableDifference_ImplicitDependenciesForTarget();
+
+    /**
+     * The meta object literal for the '<em><b>Implicit Dependencies For Reference</b></em>' reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE = eINSTANCE
+        .getGMergeableDifference_ImplicitDependenciesForReference();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementRelativePresenceImpl <em>GElement Relative Presence</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementRelativePresenceImpl
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGElementRelativePresence()
+     * @generated
+     */
+    EClass GELEMENT_RELATIVE_PRESENCE = eINSTANCE.getGElementRelativePresence();
+
+    /**
+     * The meta object literal for the '<em><b>Element Match</b></em>' reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH = eINSTANCE
+        .getGElementRelativePresence_ElementMatch();
+
+    /**
+     * The meta object literal for the '<em><b>Presence Role</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE = eINSTANCE
+        .getGElementRelativePresence_PresenceRole();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementPresenceImpl <em>GElement Presence</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementPresenceImpl
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGElementPresence()
+     * @generated
+     */
+    EClass GELEMENT_PRESENCE = eINSTANCE.getGElementPresence();
+
+    /**
+     * The meta object literal for the '<em><b>Owner Match</b></em>' reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GELEMENT_PRESENCE__OWNER_MATCH = eINSTANCE
+        .getGElementPresence_OwnerMatch();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl <em>GValue Presence</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGValuePresence()
+     * @generated
+     */
+    EClass GVALUE_PRESENCE = eINSTANCE.getGValuePresence();
+
+    /**
+     * The meta object literal for the '<em><b>Order</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GVALUE_PRESENCE__ORDER = eINSTANCE.getGValuePresence_Order();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GAttributeValuePresenceImpl <em>GAttribute Value Presence</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GAttributeValuePresenceImpl
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGAttributeValuePresence()
+     * @generated
+     */
+    EClass GATTRIBUTE_VALUE_PRESENCE = eINSTANCE.getGAttributeValuePresence();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GReferenceValuePresenceImpl <em>GReference Value Presence</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GReferenceValuePresenceImpl
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getGReferenceValuePresence()
+     * @generated
+     */
+    EClass GREFERENCE_VALUE_PRESENCE = eINSTANCE.getGReferenceValuePresence();
+
+    /**
+     * The meta object literal for the '<em><b>Value Match</b></em>' reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GREFERENCE_VALUE_PRESENCE__VALUE_MATCH = eINSTANCE
+        .getGReferenceValuePresence_ValueMatch();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.IComparison <em>IComparison</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.IComparison
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIComparison()
+     * @generated
+     */
+    EClass ICOMPARISON = eINSTANCE.getIComparison();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.IComparison.Editable <em>IEditable Comparison</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.IComparison.Editable
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIEditableComparison()
+     * @generated
+     */
+    EClass IEDITABLE_COMPARISON = eINSTANCE.getIEditableComparison();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.IMapping <em>IMapping</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.IMapping
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIMapping()
+     * @generated
+     */
+    EClass IMAPPING = eINSTANCE.getIMapping();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.IMapping.Editable <em>IEditable Mapping</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.IMapping.Editable
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIEditableMapping()
+     * @generated
+     */
+    EClass IEDITABLE_MAPPING = eINSTANCE.getIEditableMapping();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.IMatch <em>IMatch</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.IMatch
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIMatch()
+     * @generated
+     */
+    EClass IMATCH = eINSTANCE.getIMatch();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.IMatch.Editable <em>IEditable Match</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.IMatch.Editable
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIEditableMatch()
+     * @generated
+     */
+    EClass IEDITABLE_MATCH = eINSTANCE.getIEditableMatch();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference <em>IMergeable Difference</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIMergeableDifference()
+     * @generated
+     */
+    EClass IMERGEABLE_DIFFERENCE = eINSTANCE.getIMergeableDifference();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable <em>IEditable Mergeable Difference</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIEditableMergeableDifference()
+     * @generated
+     */
+    EClass IEDITABLE_MERGEABLE_DIFFERENCE = eINSTANCE
+        .getIEditableMergeableDifference();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativePresence <em>IElement Relative Presence</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativePresence
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIElementRelativePresence()
+     * @generated
+     */
+    EClass IELEMENT_RELATIVE_PRESENCE = eINSTANCE.getIElementRelativePresence();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence <em>IElement Presence</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIElementPresence()
+     * @generated
+     */
+    EClass IELEMENT_PRESENCE = eINSTANCE.getIElementPresence();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence <em>IValue Presence</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIValuePresence()
+     * @generated
+     */
+    EClass IVALUE_PRESENCE = eINSTANCE.getIValuePresence();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence <em>IAttribute Value Presence</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIAttributeValuePresence()
+     * @generated
+     */
+    EClass IATTRIBUTE_VALUE_PRESENCE = eINSTANCE.getIAttributeValuePresence();
+
+    /**
+     * The meta object literal for the '{@link org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence <em>IReference Value Presence</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIReferenceValuePresence()
+     * @generated
+     */
+    EClass IREFERENCE_VALUE_PRESENCE = eINSTANCE.getIReferenceValuePresence();
+
+    /**
+     * The meta object literal for the '<em>IEditable Tree Data Scope</em>' data type.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIEditableTreeDataScope()
+     * @generated
+     */
+    EDataType IEDITABLE_TREE_DATA_SCOPE = eINSTANCE.getIEditableTreeDataScope();
+
+    /**
+     * The meta object literal for the '<em>IMatch Policy</em>' data type.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.IMatchPolicy
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIMatchPolicy()
+     * @generated
+     */
+    EDataType IMATCH_POLICY = eINSTANCE.getIMatchPolicy();
+
+    /**
+     * The meta object literal for the '<em>IDiff Policy</em>' data type.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.IDiffPolicy
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIDiffPolicy()
+     * @generated
+     */
+    EDataType IDIFF_POLICY = eINSTANCE.getIDiffPolicy();
+
+    /**
+     * The meta object literal for the '<em>IMerge Policy</em>' data type.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.IMergePolicy
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getIMergePolicy()
+     * @generated
+     */
+    EDataType IMERGE_POLICY = eINSTANCE.getIMergePolicy();
+
+    /**
+     * The meta object literal for the '<em>Role</em>' data type.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.emf.diffmerge.generic.api.Role
+     * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GdiffdataPackageImpl#getRole()
+     * @generated
+     */
+    EDataType ROLE = eINSTANCE.getRole();
+
+  }
+
+} //GdiffdataPackage
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GAttributeValuePresenceImpl.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GAttributeValuePresenceImpl.java
new file mode 100644
index 0000000..9757c82
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GAttributeValuePresenceImpl.java
@@ -0,0 +1,175 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata.impl;
+
+import java.util.Collection;
+import org.eclipse.emf.diffmerge.generic.api.IDiffPolicy;
+import org.eclipse.emf.diffmerge.generic.api.IMatch;
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GAttributeValuePresence;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage;
+import org.eclipse.emf.ecore.EClass;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>EAttribute Value Presence</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public abstract class GAttributeValuePresenceImpl<E, A, R> extends
+    GValuePresenceImpl<E, A, R> implements GAttributeValuePresence<E, A, R> {
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected GAttributeValuePresenceImpl() {
+    super();
+  }
+
+  /**
+   * Constructor
+   * @param elementMatch_p the non-null match for the element holding the value
+   * @param attribute_p the non-null attribute holding the value
+   * @param value_p the non-null value held
+   * @param presenceRole_p the role in which the value is held: TARGET or REFERENCE
+   * @param isOrder_p whether the value presence is solely due to ordering
+   * @generated NOT
+   */
+  public GAttributeValuePresenceImpl(GMatch<E, A, R> elementMatch_p,
+      A attribute_p, Object value_p, Role presenceRole_p, boolean isOrder_p) {
+    super(elementMatch_p, presenceRole_p, isOrder_p);
+    setAttribute(attribute_p);
+    setValue(value_p);
+    ((IMatch.Editable<E>) elementMatch).addRelatedDifference(this);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return GdiffdataPackage.Literals.GATTRIBUTE_VALUE_PRESENCE;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GAttributeValuePresence#setValue(java.lang.Object)
+   * @generated NOT
+   */
+  public abstract void setValue(Object value);
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#getFeature()
+   * @generated NOT
+   */
+  @Override
+  public abstract A getFeature();
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated NOT
+   */
+  public abstract void setAttribute(A attribute);
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#getSymmetrical()
+   * @generated NOT
+   */
+  @Override
+  public IAttributeValuePresence<E> getSymmetrical() {
+    IAttributeValuePresence<E> result = null;
+    if (!isManyFeature()) {
+      Collection<IAttributeValuePresence<E>> candidates = getElementMatch()
+          .getAttributeDifferences(getFeature());
+      assert candidates.size() <= 2; // Because !isMany()
+      for (IAttributeValuePresence<E> candidate : candidates) {
+        if (candidate.getPresenceRole() == getAbsenceRole()) {
+          result = candidate;
+          break;
+        }
+      }
+    } else if (isOrder()) {
+      result = getElementMatch().getAttributeOrderDifference(getFeature(),
+          getAbsenceRole());
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence#isChangeableFeature()
+   * @generated NOT
+   */
+  public boolean isChangeableFeature() {
+    return getPresenceScope().mIsChangeableAttribute(getFeature());
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#isManyFeature()
+   * @generated NOT
+   */
+  @Override
+  public boolean isManyFeature() {
+    return getPresenceScope().mIsManyAttribute(getFeature());
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativeDifference#isUnrelatedToContainmentTree()
+   * @generated NOT
+   */
+  public boolean isUnrelatedToContainmentTree() {
+    return true;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#mergeOrder()
+   * @generated NOT
+   */
+  @Override
+  protected void mergeOrder() {
+    // TODO Implement
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#mergeValueAddition()
+   * @generated NOT
+   */
+  @Override
+  protected void mergeValueAddition() {
+    IEditableTreeDataScope<E> absenceScope = getAbsenceScope();
+    E holderMatch = getMatchOfHolder();
+    assert holderMatch != null; // Must be guaranteed by diff dependency handling
+    absenceScope.addAttributeValue(holderMatch, getFeature(), getValue());
+    IDiffPolicy<E> diffPolicy = getComparison().getLastDiffPolicy();
+    if (diffPolicy != null && diffPolicy.considerOrderedAttribute(getFeature(),
+        getPresenceScope())) {
+      // TODO Implement
+    }
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#mergeValueRemoval()
+   * @generated NOT
+   */
+  @Override
+  public void mergeValueRemoval() {
+    IEditableTreeDataScope<E> presenceScope = getPresenceScope();
+    presenceScope.removeAttributeValue(getHolder(), getFeature(), getValue());
+  }
+
+} //GAttributeValuePresenceImpl
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GComparisonImpl.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GComparisonImpl.java
new file mode 100644
index 0000000..20d4f07
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GComparisonImpl.java
@@ -0,0 +1,978 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata.impl;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.SubMonitor;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.AbstractTreeIterator;
+import org.eclipse.emf.common.util.TreeIterator;
+import org.eclipse.emf.diffmerge.generic.Messages;
+import org.eclipse.emf.diffmerge.generic.api.IComparison;
+import org.eclipse.emf.diffmerge.generic.api.IDiffPolicy;
+import org.eclipse.emf.diffmerge.generic.api.IMapping;
+import org.eclipse.emf.diffmerge.generic.api.IMatch;
+import org.eclipse.emf.diffmerge.generic.api.IMatchPolicy;
+import org.eclipse.emf.diffmerge.generic.api.IMergePolicy;
+import org.eclipse.emf.diffmerge.generic.api.IMergeSelector;
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.diff.IDifference;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope;
+import org.eclipse.emf.diffmerge.generic.api.scopes.ITreeDataScope;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage;
+import org.eclipse.emf.diffmerge.generic.impl.helpers.DiffOperation;
+import org.eclipse.emf.diffmerge.generic.impl.helpers.MatchOperation;
+import org.eclipse.emf.diffmerge.generic.impl.helpers.MergeOperation;
+import org.eclipse.emf.diffmerge.generic.impl.policies.ConfigurableMatchPolicy;
+import org.eclipse.emf.diffmerge.generic.impl.policies.DefaultDiffPolicy;
+import org.eclipse.emf.diffmerge.generic.impl.policies.DefaultMergePolicy;
+import org.eclipse.emf.diffmerge.generic.util.IExpensiveOperation;
+import org.eclipse.emf.diffmerge.structures.IEqualityTester;
+import org.eclipse.emf.diffmerge.structures.common.FArrayList;
+import org.eclipse.emf.diffmerge.structures.common.FHashSet;
+import org.eclipse.emf.diffmerge.structures.common.FOrderedSet;
+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>GComparison</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GComparisonImpl#getAncestorScope <em>Ancestor Scope</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GComparisonImpl#getReferenceScope <em>Reference Scope</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GComparisonImpl#getTargetScope <em>Target Scope</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GComparisonImpl#getLastMatchPolicy <em>Last Match Policy</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GComparisonImpl#getLastDiffPolicy <em>Last Diff Policy</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GComparisonImpl#getLastMergePolicy <em>Last Merge Policy</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GComparisonImpl#getMapping <em>Mapping</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public abstract class GComparisonImpl<E, A, R> extends GIdentifiedImpl
+    implements GComparison<E, A, R> {
+  /**
+   * The cached value of the '{@link #getAncestorScope() <em>Ancestor Scope</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getAncestorScope()
+   * @generated
+   * @ordered
+   */
+  protected IEditableTreeDataScope<E> ancestorScope;
+
+  /**
+   * The cached value of the '{@link #getReferenceScope() <em>Reference Scope</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getReferenceScope()
+   * @generated
+   * @ordered
+   */
+  protected IEditableTreeDataScope<E> referenceScope;
+
+  /**
+   * The cached value of the '{@link #getTargetScope() <em>Target Scope</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getTargetScope()
+   * @generated
+   * @ordered
+   */
+  protected IEditableTreeDataScope<E> targetScope;
+
+  /**
+   * The cached value of the '{@link #getLastMatchPolicy() <em>Last Match Policy</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getLastMatchPolicy()
+   * @generated
+   * @ordered
+   */
+  protected IMatchPolicy<E> lastMatchPolicy;
+
+  /**
+   * The cached value of the '{@link #getLastDiffPolicy() <em>Last Diff Policy</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getLastDiffPolicy()
+   * @generated
+   * @ordered
+   */
+  protected IDiffPolicy<E> lastDiffPolicy;
+
+  /**
+   * The cached value of the '{@link #getLastMergePolicy() <em>Last Merge Policy</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getLastMergePolicy()
+   * @generated
+   * @ordered
+   */
+  protected IMergePolicy<E> lastMergePolicy;
+
+  /**
+   * The cached value of the '{@link #getMapping() <em>Mapping</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getMapping()
+   * @generated
+   * @ordered
+   */
+  protected GMapping<E, A, R> mapping;
+
+  /**
+   * The non-null sets of duplicate match IDs per role
+   * @generated NOT
+   */
+  private final Map<Role, Set<Object>> _duplicateIDs;
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated NOT
+   */
+  protected GComparisonImpl() {
+    super();
+    Map<Role, Set<Object>> duplicateIDs = new HashMap<Role, Set<Object>>(3);
+    for (Role role : Role.values()) {
+      duplicateIDs.put(role, new HashSet<Object>(0));
+    }
+    _duplicateIDs = Collections.unmodifiableMap(duplicateIDs);
+  }
+
+  /**
+   * Simplified constructor
+   * @param targetScope_p the non-null model scope playing the TARGET comparison role
+   * @param referenceScope_p the non-null model scope playing the REFERENCE comparison role
+   * @generated NOT
+   */
+  public GComparisonImpl(IEditableTreeDataScope<E> targetScope_p,
+      IEditableTreeDataScope<E> referenceScope_p) {
+    this(targetScope_p, referenceScope_p, null);
+  }
+
+  /**
+   * Full constructor
+   * @param targetScope_p the non-null model scope playing the TARGET comparison role
+   * @param referenceScope_p the non-null model scope playing the REFERENCE comparison role
+   * @param ancestorScope_p the optional model scope playing the ANCESTOR comparison role
+   * @generated NOT
+   */
+  public GComparisonImpl(IEditableTreeDataScope<E> targetScope_p,
+      IEditableTreeDataScope<E> referenceScope_p,
+      IEditableTreeDataScope<E> ancestorScope_p) {
+    this();
+    setTargetScope(targetScope_p);
+    setReferenceScope(referenceScope_p);
+    setAncestorScope(ancestorScope_p);
+    setMapping(newMapping());
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return GdiffdataPackage.Literals.GCOMPARISON;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public IEditableTreeDataScope<E> getAncestorScope() {
+    return ancestorScope;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setAncestorScope(IEditableTreeDataScope<E> newAncestorScope) {
+    IEditableTreeDataScope<E> oldAncestorScope = ancestorScope;
+    ancestorScope = newAncestorScope;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GCOMPARISON__ANCESTOR_SCOPE, oldAncestorScope,
+          ancestorScope));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public IEditableTreeDataScope<E> getReferenceScope() {
+    return referenceScope;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setReferenceScope(IEditableTreeDataScope<E> newReferenceScope) {
+    IEditableTreeDataScope<E> oldReferenceScope = referenceScope;
+    referenceScope = newReferenceScope;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GCOMPARISON__REFERENCE_SCOPE, oldReferenceScope,
+          referenceScope));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public IEditableTreeDataScope<E> getTargetScope() {
+    return targetScope;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setTargetScope(IEditableTreeDataScope<E> newTargetScope) {
+    IEditableTreeDataScope<E> oldTargetScope = targetScope;
+    targetScope = newTargetScope;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GCOMPARISON__TARGET_SCOPE, oldTargetScope,
+          targetScope));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public IMatchPolicy<E> getLastMatchPolicy() {
+    return lastMatchPolicy;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setLastMatchPolicy(IMatchPolicy<E> newLastMatchPolicy) {
+    IMatchPolicy<E> oldLastMatchPolicy = lastMatchPolicy;
+    lastMatchPolicy = newLastMatchPolicy;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GCOMPARISON__LAST_MATCH_POLICY, oldLastMatchPolicy,
+          lastMatchPolicy));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public IDiffPolicy<E> getLastDiffPolicy() {
+    return lastDiffPolicy;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setLastDiffPolicy(IDiffPolicy<E> newLastDiffPolicy) {
+    IDiffPolicy<E> oldLastDiffPolicy = lastDiffPolicy;
+    lastDiffPolicy = newLastDiffPolicy;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GCOMPARISON__LAST_DIFF_POLICY, oldLastDiffPolicy,
+          lastDiffPolicy));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public IMergePolicy<E> getLastMergePolicy() {
+    return lastMergePolicy;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setLastMergePolicy(IMergePolicy<E> newLastMergePolicy) {
+    IMergePolicy<E> oldLastMergePolicy = lastMergePolicy;
+    lastMergePolicy = newLastMergePolicy;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GCOMPARISON__LAST_MERGE_POLICY, oldLastMergePolicy,
+          lastMergePolicy));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public GMapping<E, A, R> getMapping() {
+    return mapping;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated NOT
+   */
+  public NotificationChain basicSetMapping(GMapping<E, A, R> newMapping,
+      NotificationChain msgs) {
+    NotificationChain result = msgs;
+    GMapping<E, A, R> oldMapping = mapping;
+    mapping = newMapping;
+    if (eNotificationRequired()) {
+      ENotificationImpl notification = new ENotificationImpl(this,
+          Notification.SET, GdiffdataPackage.GCOMPARISON__MAPPING, oldMapping,
+          newMapping);
+      if (result == null) {
+        result = notification;
+      } else {
+        result.add(notification);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setMapping(GMapping<E, A, R> newMapping) {
+    if (newMapping != mapping) {
+      NotificationChain msgs = null;
+      if (mapping != null)
+        msgs = ((InternalEObject) mapping).eInverseRemove(this,
+            EOPPOSITE_FEATURE_BASE - GdiffdataPackage.GCOMPARISON__MAPPING,
+            null, msgs);
+      if (newMapping != null)
+        msgs = ((InternalEObject) newMapping).eInverseAdd(this,
+            EOPPOSITE_FEATURE_BASE - GdiffdataPackage.GCOMPARISON__MAPPING,
+            null, msgs);
+      msgs = basicSetMapping(newMapping, msgs);
+      if (msgs != null)
+        msgs.dispatch();
+    } else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GCOMPARISON__MAPPING, newMapping, newMapping));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd,
+      int featureID, NotificationChain msgs) {
+    switch (featureID) {
+    case GdiffdataPackage.GCOMPARISON__MAPPING:
+      return basicSetMapping(null, 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 GdiffdataPackage.GCOMPARISON__ANCESTOR_SCOPE:
+      return getAncestorScope();
+    case GdiffdataPackage.GCOMPARISON__REFERENCE_SCOPE:
+      return getReferenceScope();
+    case GdiffdataPackage.GCOMPARISON__TARGET_SCOPE:
+      return getTargetScope();
+    case GdiffdataPackage.GCOMPARISON__LAST_MATCH_POLICY:
+      return getLastMatchPolicy();
+    case GdiffdataPackage.GCOMPARISON__LAST_DIFF_POLICY:
+      return getLastDiffPolicy();
+    case GdiffdataPackage.GCOMPARISON__LAST_MERGE_POLICY:
+      return getLastMergePolicy();
+    case GdiffdataPackage.GCOMPARISON__MAPPING:
+      return getMapping();
+    }
+    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 GdiffdataPackage.GCOMPARISON__ANCESTOR_SCOPE:
+      setAncestorScope((IEditableTreeDataScope<E>) newValue);
+      return;
+    case GdiffdataPackage.GCOMPARISON__REFERENCE_SCOPE:
+      setReferenceScope((IEditableTreeDataScope<E>) newValue);
+      return;
+    case GdiffdataPackage.GCOMPARISON__TARGET_SCOPE:
+      setTargetScope((IEditableTreeDataScope<E>) newValue);
+      return;
+    case GdiffdataPackage.GCOMPARISON__LAST_MATCH_POLICY:
+      setLastMatchPolicy((IMatchPolicy<E>) newValue);
+      return;
+    case GdiffdataPackage.GCOMPARISON__LAST_DIFF_POLICY:
+      setLastDiffPolicy((IDiffPolicy<E>) newValue);
+      return;
+    case GdiffdataPackage.GCOMPARISON__LAST_MERGE_POLICY:
+      setLastMergePolicy((IMergePolicy<E>) newValue);
+      return;
+    case GdiffdataPackage.GCOMPARISON__MAPPING:
+      setMapping((GMapping<E, A, R>) newValue);
+      return;
+    }
+    super.eSet(featureID, newValue);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID) {
+    switch (featureID) {
+    case GdiffdataPackage.GCOMPARISON__ANCESTOR_SCOPE:
+      setAncestorScope((IEditableTreeDataScope<E>) null);
+      return;
+    case GdiffdataPackage.GCOMPARISON__REFERENCE_SCOPE:
+      setReferenceScope((IEditableTreeDataScope<E>) null);
+      return;
+    case GdiffdataPackage.GCOMPARISON__TARGET_SCOPE:
+      setTargetScope((IEditableTreeDataScope<E>) null);
+      return;
+    case GdiffdataPackage.GCOMPARISON__LAST_MATCH_POLICY:
+      setLastMatchPolicy((IMatchPolicy<E>) null);
+      return;
+    case GdiffdataPackage.GCOMPARISON__LAST_DIFF_POLICY:
+      setLastDiffPolicy((IDiffPolicy<E>) null);
+      return;
+    case GdiffdataPackage.GCOMPARISON__LAST_MERGE_POLICY:
+      setLastMergePolicy((IMergePolicy<E>) null);
+      return;
+    case GdiffdataPackage.GCOMPARISON__MAPPING:
+      setMapping((GMapping<E, A, R>) null);
+      return;
+    }
+    super.eUnset(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID) {
+    switch (featureID) {
+    case GdiffdataPackage.GCOMPARISON__ANCESTOR_SCOPE:
+      return ancestorScope != null;
+    case GdiffdataPackage.GCOMPARISON__REFERENCE_SCOPE:
+      return referenceScope != null;
+    case GdiffdataPackage.GCOMPARISON__TARGET_SCOPE:
+      return targetScope != null;
+    case GdiffdataPackage.GCOMPARISON__LAST_MATCH_POLICY:
+      return lastMatchPolicy != null;
+    case GdiffdataPackage.GCOMPARISON__LAST_DIFF_POLICY:
+      return lastDiffPolicy != null;
+    case GdiffdataPackage.GCOMPARISON__LAST_MERGE_POLICY:
+      return lastMergePolicy != null;
+    case GdiffdataPackage.GCOMPARISON__MAPPING:
+      return mapping != null;
+    }
+    return super.eIsSet(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString() {
+    if (eIsProxy())
+      return super.toString();
+
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (ancestorScope: "); //$NON-NLS-1$
+    result.append(ancestorScope);
+    result.append(", referenceScope: "); //$NON-NLS-1$
+    result.append(referenceScope);
+    result.append(", targetScope: "); //$NON-NLS-1$
+    result.append(targetScope);
+    result.append(", lastMatchPolicy: "); //$NON-NLS-1$
+    result.append(lastMatchPolicy);
+    result.append(", lastDiffPolicy: "); //$NON-NLS-1$
+    result.append(lastDiffPolicy);
+    result.append(", lastMergePolicy: "); //$NON-NLS-1$
+    result.append(lastMergePolicy);
+    result.append(')');
+    return result.toString();
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#clear()
+   * @generated NOT
+   */
+  public void clear() {
+    ((IMapping.Editable<E>) getMapping()).clear();
+    setLastMatchPolicy(null);
+    setLastDiffPolicy(null);
+    setLastMergePolicy(null);
+    for (Role role : Role.values()) {
+      _duplicateIDs.get(role).clear();
+    }
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#compute(org.eclipse.emf.diffmerge.generic.api.IMatchPolicy, org.eclipse.emf.diffmerge.generic.api.IDiffPolicy, org.eclipse.emf.diffmerge.generic.api.IMergePolicy, org.eclipse.core.runtime.IProgressMonitor)
+   * @generated NOT
+   */
+  public IStatus compute(IMatchPolicy<E> matchPolicy_p,
+      IDiffPolicy<E> diffPolicy_p, IMergePolicy<E> mergePolicy_p,
+      IProgressMonitor monitor_p) {
+    // Monitor
+    IProgressMonitor nonNullMonitor = monitor_p != null ? monitor_p
+        : new NullProgressMonitor();
+    SubMonitor subMonitor = SubMonitor.convert(nonNullMonitor,
+        Messages.Comparison_Task_Main, 2);
+    // Policies
+    setLastMatchPolicy(
+        matchPolicy_p != null ? matchPolicy_p : getDefaultMatchPolicy());
+    setLastDiffPolicy(
+        diffPolicy_p != null ? diffPolicy_p : getDefaultDiffPolicy());
+    setLastMergePolicy(
+        mergePolicy_p != null ? mergePolicy_p : getDefaultMergePolicy());
+    // Behavior
+    IStatus result = computeMatch(getLastMatchPolicy(), subMonitor.newChild(1));
+    if (result.isOK()) {
+      result = computeDiff(getLastDiffPolicy(), getLastMergePolicy(),
+          subMonitor.newChild(1));
+    }
+    return result;
+  }
+
+  /**
+   * Execute the Match phase of the comparison process
+   * @param matchPolicy_p a non-null match policy
+   * @param monitor_p a non-null progress monitor
+   * @return a non-null status of the execution
+   * @generated NOT
+   */
+  protected IStatus computeMatch(IMatchPolicy<E> matchPolicy_p,
+      IProgressMonitor monitor_p) {
+    IExpensiveOperation matchOperation = getMatchOperation(matchPolicy_p,
+        _duplicateIDs);
+    IStatus result = matchOperation.run(monitor_p);
+    return result;
+  }
+
+  /**
+   * Execute the Diff phase of the comparison process
+   * @param diffPolicy_p a non-null diff policy
+   * @param mergePolicy_p a non-null merge policy
+   * @param monitor_p a non-null progress monitor
+   * @return a non-null status of the execution
+   * @generated NOT
+   */
+  protected IStatus computeDiff(IDiffPolicy<E> diffPolicy_p,
+      IMergePolicy<E> mergePolicy_p, IProgressMonitor monitor_p) {
+    IExpensiveOperation diffOperation = getDiffOperation(diffPolicy_p,
+        mergePolicy_p);
+    IStatus result = diffOperation.run(monitor_p);
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getAllContents(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  @SuppressWarnings("serial")
+  public TreeIterator<IMatch<E>> getAllContents(final Role role_p) {
+    return new AbstractTreeIterator<IMatch<E>>(this, false) {
+      /**
+       * @see org.eclipse.emf.common.util.AbstractTreeIterator#getChildren(Object)
+       */
+      @SuppressWarnings({ "rawtypes", "unchecked" })
+      @Override
+      protected Iterator<? extends IMatch<E>> getChildren(Object object_p) {
+        Iterator<? extends IMatch<E>> result;
+        if (object_p instanceof IComparison) {
+          result = ((IComparison) object_p).getContents(role_p).iterator();
+        } else {
+          result = getContentsOf((IMatch) object_p, role_p).iterator();
+        }
+        return result;
+      }
+    };
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getContainerOf(org.eclipse.emf.diffmerge.generic.api.IMatch, org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public IMatch<E> getContainerOf(IMatch<E> match_p, Role role_p) {
+    IMatch<E> result = null;
+    E child = match_p.get(role_p);
+    if (child != null) {
+      ITreeDataScope<E> scope = getScope(role_p);
+      E container = scope.getContainer(child);
+      if (container != null) {
+        result = getMapping().getMatchFor(container, role_p);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getContents()
+   * @generated NOT
+   */
+  public List<IMatch<E>> getContents() {
+    List<IMatch<E>> targetMatches = getContents(Role.TARGET);
+    List<IMatch<E>> referenceMatches = getContents(Role.REFERENCE);
+    List<IMatch<E>> result = new FArrayList<IMatch<E>>(referenceMatches, null);
+    for (IMatch<E> targetMatch : targetMatches) {
+      if (!result.contains(targetMatch))
+        result.add(targetMatch);
+    }
+    return Collections.unmodifiableList(result);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getContents(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public List<IMatch<E>> getContents(Role role_p) {
+    List<IMatch<E>> result = new FArrayList<IMatch<E>>();
+    // Defining 'contents': list of elements whose matches must be retrieved
+    Iterable<E> contents = getScope(role_p).getRoots();
+    // Retrieving matches
+    for (E child : contents) {
+      IMatch<E> childMatch = getMapping().getMatchFor(child, role_p);
+      if (childMatch != null)
+        result.add(childMatch);
+    }
+    return Collections.unmodifiableList(result);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getContentsOf(org.eclipse.emf.diffmerge.generic.api.IMatch)
+   * @generated NOT
+   */
+  public List<IMatch<E>> getContentsOf(IMatch<E> match_p) {
+    List<IMatch<E>> targetMatches = getContentsOf(match_p, Role.TARGET);
+    List<IMatch<E>> referenceMatches = getContentsOf(match_p, Role.REFERENCE);
+    List<IMatch<E>> result = new FOrderedSet<IMatch<E>>(referenceMatches, null);
+    for (IMatch<E> targetMatch : targetMatches) {
+      result.add(targetMatch);
+    }
+    return Collections.unmodifiableList(result);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getContentsOf(org.eclipse.emf.diffmerge.generic.api.IMatch, org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public List<IMatch<E>> getContentsOf(IMatch<E> match_p, Role role_p) {
+    List<IMatch<E>> result = new FArrayList<IMatch<E>>();
+    // Defining 'contents': list of elements whose matches must be retrieved
+    Iterable<E> contents = null;
+    E container = match_p.get(role_p);
+    if (container != null) {
+      ITreeDataScope<E> scope = getScope(role_p);
+      contents = scope.getContents(container);
+    }
+    // Retrieving matches
+    if (contents != null) {
+      for (E child : contents) {
+        IMatch<E> childMatch = getMapping().getMatchFor(child, role_p);
+        if (childMatch != null)
+          result.add(childMatch);
+      }
+    }
+    return Collections.unmodifiableList(result);
+  }
+
+  /**
+   * Return a default diff policy
+   * @return a non-null object
+   * @generated NOT
+   */
+  protected IDiffPolicy<E> getDefaultDiffPolicy() {
+    return new DefaultDiffPolicy<E>();
+  }
+
+  /**
+   * Return a default match policy
+   * @return a non-null object
+   * @generated NOT
+   */
+  protected IMatchPolicy<E> getDefaultMatchPolicy() {
+    return new ConfigurableMatchPolicy<E>();
+  }
+
+  /**
+   * Return a default merge policy
+   * @return a non-null object
+   * @generated NOT
+   */
+  protected IMergePolicy<E> getDefaultMergePolicy() {
+    return new DefaultMergePolicy<E>();
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getDifferences(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public List<IDifference<E>> getDifferences(Role role_p) {
+    List<IDifference<E>> result = new FArrayList<IDifference<E>>();
+    Iterator<IMatch<E>> it = getAllContents(role_p);
+    while (it.hasNext()) {
+      IMatch<E> current = it.next();
+      result.addAll(current.getPresenceDifferencesIn(role_p));
+    }
+    return result;
+  }
+
+  /**
+   * Return an operation for executing the Diff phase
+   * @param diffPolicy_p an optional diff policy
+   * @param mergePolicy_p an optional merge policy
+   * @return a non-null operation which is configured to be applied on the given comparison data
+   * @generated NOT
+   */
+  protected IExpensiveOperation getDiffOperation(IDiffPolicy<E> diffPolicy_p,
+      IMergePolicy<E> mergePolicy_p) {
+    return new DiffOperation<E>(this, diffPolicy_p, mergePolicy_p);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getDuplicateMatchIDs(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public Collection<Object> getDuplicateMatchIDs(Role role_p) {
+    return _duplicateIDs.get(role_p);
+  }
+
+  /**
+   * Return an operation for executing the Match phase
+   * @param policy_p an optional match policy
+   * @param duplicateIDs_p an optional map that associates each role with an empty, modifiable set of duplicate match IDs 
+   * @return a non-null operation which is configured to be applied on the given comparison data
+   * @generated NOT
+   */
+  protected IExpensiveOperation getMatchOperation(IMatchPolicy<E> policy_p,
+      Map<Role, Set<Object>> duplicateIDs_p) {
+    return new MatchOperation<E>(this, policy_p, duplicateIDs_p);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getNbDifferences()
+   * @generated NOT
+   */
+  public int getNbDifferences() {
+    int result = 0;
+    for (IMatch<E> match : getMapping().getContents()) {
+      result += match.getRelatedDifferences().size();
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getNbNoContainmentDifferences()
+   * @generated NOT
+   */
+  public int getNbNoContainmentDifferences() {
+    int result = 0;
+    for (IMatch<E> match : getMapping().getContents()) {
+      result += match.getNbNoContainmentDifferences();
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#getRemainingDifferences()
+   * @generated NOT
+   */
+  public Collection<IDifference<E>> getRemainingDifferences() {
+    Collection<IDifference<E>> result = new FHashSet<IDifference<E>>(
+        IEqualityTester.BY_EQUALS);
+    for (IMatch<E> match : getMapping().getContents()) {
+      for (IDifference<E> difference : match.getAllDifferences()) {
+        if (!difference.isMerged())
+          result.add(difference);
+      }
+    }
+    return Collections.unmodifiableCollection(result);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison.Editable#getScope(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public IEditableTreeDataScope<E> getScope(Role role) {
+    IEditableTreeDataScope<E> result;
+    switch (role) {
+    case TARGET:
+      result = getTargetScope();
+      break;
+    case REFERENCE:
+      result = getReferenceScope();
+      break;
+    default:
+      result = getAncestorScope();
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#hasRemainingDifferences()
+   * @generated NOT
+   */
+  public boolean hasRemainingDifferences() {
+    for (IMatch<E> match : getMapping().getContents()) {
+      for (IDifference<E> difference : match.getAllDifferences()) {
+        if (!difference.isMerged())
+          return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#isConsistent()
+   * @generated NOT
+   */
+  public boolean isConsistent() {
+    for (Role role : Role.values()) {
+      if (!getDuplicateMatchIDs(role).isEmpty())
+        return false;
+    }
+    return true;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#isThreeWay()
+   * @generated NOT
+   */
+  public boolean isThreeWay() {
+    return getAncestorScope() != null;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#merge(org.eclipse.emf.diffmerge.generic.api.Role, boolean, org.eclipse.core.runtime.IProgressMonitor)
+   * @generated not
+   */
+  public Collection<IDifference<E>> merge(final Role destination_p,
+      boolean updateReferences_p, IProgressMonitor monitor_p) {
+    Collection<IDifference<E>> result = merge(new IMergeSelector<E>() {
+      /**
+       * @see org.eclipse.emf.diffmerge.generic.api.IMergeSelector#getMergeDirection(org.eclipse.emf.diffmerge.generic.api.diff.IDifference)
+       */
+      public Role getMergeDirection(IDifference<E> difference_p) {
+        return destination_p;
+      }
+    }, updateReferences_p, monitor_p);
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#merge(java.util.Collection, org.eclipse.emf.diffmerge.generic.api.Role, boolean, org.eclipse.core.runtime.IProgressMonitor)
+   * @generated NOT
+   */
+  public Collection<IDifference<E>> merge(
+      Collection<? extends IDifference<E>> differences_p, Role destination_p,
+      boolean updateReferences_p, IProgressMonitor monitor_p) {
+    MergeOperation<E> operation = new MergeOperation<E>(this, differences_p,
+        destination_p, updateReferences_p);
+    operation.run(monitor_p);
+    return operation.getOutput();
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison#merge(org.eclipse.emf.diffmerge.generic.api.IMergeSelector, boolean, org.eclipse.core.runtime.IProgressMonitor)
+   * @generated NOT
+   */
+  public Collection<IDifference<E>> merge(IMergeSelector<E> merger_p,
+      boolean updateReferences_p, IProgressMonitor monitor_p) {
+    MergeOperation<E> operation = new MergeOperation<E>(this, merger_p,
+        updateReferences_p);
+    operation.run(monitor_p);
+    return operation.getOutput();
+  }
+
+  /**
+   * Create and return a mapping for this comparison
+   * @return a non-null mapping
+   * @generated NOT
+   */
+  protected abstract GMapping<E, A, R> newMapping();
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IComparison.Editable#swapScopes()
+   * @generated NOT
+   */
+  public boolean swapScopes() {
+    boolean isEmpty = getMapping().isEmpty();
+    if (isEmpty) {
+      IEditableTreeDataScope<E> formerTarget = targetScope;
+      targetScope = referenceScope;
+      referenceScope = formerTarget;
+    }
+    return isEmpty;
+  }
+
+} //GComparisonImpl
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GElementPresenceImpl.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GElementPresenceImpl.java
new file mode 100644
index 0000000..77a170a
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GElementPresenceImpl.java
@@ -0,0 +1,274 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.diffmerge.generic.api.IDiffPolicy;
+import org.eclipse.emf.diffmerge.generic.api.IMapping;
+import org.eclipse.emf.diffmerge.generic.api.IMatch;
+import org.eclipse.emf.diffmerge.generic.api.IMergePolicy;
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GElementPresence;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage;
+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>EElement Presence</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementPresenceImpl#getOwnerMatch <em>Owner Match</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public abstract class GElementPresenceImpl<E, A, R> extends
+    GElementRelativePresenceImpl<E, A, R> implements GElementPresence<E, A, R> {
+  /**
+   * The cached value of the '{@link #getOwnerMatch() <em>Owner Match</em>}' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getOwnerMatch()
+   * @generated
+   * @ordered
+   */
+  protected GMatch<E, A, R> ownerMatch;
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected GElementPresenceImpl() {
+    super();
+  }
+
+  /**
+   * Constructor
+   * @param match_p the non-null match to which this difference is relative
+   * @param ownerMatch_p a potentially null match for the owner of the element
+   * @param presenceRole_p the non-null role in which the element is present: TARGET or REFERENCE
+   * @generated NOT
+   */
+  public GElementPresenceImpl(GMatch<E, A, R> match_p,
+      GMatch<E, A, R> ownerMatch_p, Role presenceRole_p) {
+    super(match_p, presenceRole_p);
+    setOwnerMatch(ownerMatch_p);
+    ((IMatch.Editable<E>) elementMatch).addRelatedDifference(this);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return GdiffdataPackage.Literals.GELEMENT_PRESENCE;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  public GMatch<E, A, R> getOwnerMatch() {
+    if (ownerMatch != null && ownerMatch.eIsProxy()) {
+      InternalEObject oldOwnerMatch = (InternalEObject) ownerMatch;
+      ownerMatch = (GMatch<E, A, R>) eResolveProxy(oldOwnerMatch);
+      if (ownerMatch != oldOwnerMatch) {
+        if (eNotificationRequired())
+          eNotify(new ENotificationImpl(this, Notification.RESOLVE,
+              GdiffdataPackage.GELEMENT_PRESENCE__OWNER_MATCH, oldOwnerMatch,
+              ownerMatch));
+      }
+    }
+    return ownerMatch;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public GMatch<E, A, R> basicGetOwnerMatch() {
+    return ownerMatch;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setOwnerMatch(GMatch<E, A, R> newOwnerMatch) {
+    GMatch<E, A, R> oldOwnerMatch = ownerMatch;
+    ownerMatch = newOwnerMatch;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GELEMENT_PRESENCE__OWNER_MATCH, oldOwnerMatch,
+          ownerMatch));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType) {
+    switch (featureID) {
+    case GdiffdataPackage.GELEMENT_PRESENCE__OWNER_MATCH:
+      if (resolve)
+        return getOwnerMatch();
+      return basicGetOwnerMatch();
+    }
+    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 GdiffdataPackage.GELEMENT_PRESENCE__OWNER_MATCH:
+      setOwnerMatch((GMatch<E, A, R>) newValue);
+      return;
+    }
+    super.eSet(featureID, newValue);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID) {
+    switch (featureID) {
+    case GdiffdataPackage.GELEMENT_PRESENCE__OWNER_MATCH:
+      setOwnerMatch((GMatch<E, A, R>) null);
+      return;
+    }
+    super.eUnset(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID) {
+    switch (featureID) {
+    case GdiffdataPackage.GELEMENT_PRESENCE__OWNER_MATCH:
+      return ownerMatch != null;
+    }
+    return super.eIsSet(featureID);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence#getElement()
+   * @generated NOT
+   */
+  public E getElement() {
+    return getElementMatch().get(getPresenceRole());
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativeDifference#isUnrelatedToContainmentTree()
+   * @generated NOT
+   */
+  public boolean isUnrelatedToContainmentTree() {
+    return false;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence#isRoot()
+   * @generated NOT
+   */
+  public boolean isRoot() {
+    return getOwnerMatch() == null;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementRelativePresenceImpl#mergeAddition()
+   * @generated NOT
+   */
+  @Override
+  protected void mergeAddition() {
+    IMapping.Editable<E> mapping = getComparison().getMapping();
+    IMatch<E> eltMatch = getElementMatch();
+    E clone = eltMatch.isPartial() ? mapping.completeMatch(eltMatch)
+        : eltMatch.get(getAbsenceRole());
+    boolean addedToScope = false;
+    boolean actuallyAdded = false;
+    IMergePolicy<E> mergePolicy = getComparison().getLastMergePolicy();
+    IEditableTreeDataScope<E> absenceScope = getAbsenceScope();
+    if (getComparison().getLastMergePolicy()
+        .bindPresenceToOwnership(absenceScope) && !isRoot()) {
+      E container = getOwnerMatch().get(getAbsenceRole());
+      if (container != null) {
+        Object containment = getPresenceScope().getContainment(getElement());
+        actuallyAdded = absenceScope.addReferenceValue(container, containment,
+            clone);
+        addedToScope = true; // Even if !actuallyAdded
+        // Order handling
+        IDiffPolicy<E> diffPolicy = getComparison().getLastDiffPolicy();
+        if (diffPolicy != null && actuallyAdded
+            && diffPolicy.considerOrderedReference(containment, absenceScope)) {
+          // Move added value if required
+          int index = mergePolicy.getDesiredValuePosition(getComparison(),
+              getAbsenceRole(), getOwnerMatch(), containment, getElement());
+          if (index >= 0) {
+            absenceScope.moveReferenceValue(container, containment, index, -1);
+          }
+        }
+      }
+      // Else container will be created and ownership automatically applied by the copier,
+      // if containment tree of the scope is consistent with matching
+    }
+    if (!addedToScope) {
+      actuallyAdded = absenceScope.add(clone);
+    }
+    if (actuallyAdded) {
+      mergePolicy.setID(getElement(), getPresenceScope(), clone, absenceScope);
+    }
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementRelativePresenceImpl#mergeRemoval()
+   * @generated NOT
+   */
+  @Override
+  protected void mergeRemoval() {
+    if (isRoot() || getElementMatch()
+        .getOwnershipDifference(getPresenceRole()) == null) {
+      IEditableTreeDataScope<E> presenceScope = getPresenceScope();
+      E element = getElement();
+      getElementMatch().getMapping().disconnect(getPresenceRole(), element);
+      presenceScope.remove(element);
+    } // Else handled by ownership
+  }
+
+} //GElementPresenceImpl
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/diffdata/impl/EElementRelativePresenceImpl.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GElementRelativePresenceImpl.java
similarity index 66%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/diffdata/impl/EElementRelativePresenceImpl.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GElementRelativePresenceImpl.java
index 3a98291..cb52e5e 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/diffdata/impl/EElementRelativePresenceImpl.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GElementRelativePresenceImpl.java
@@ -9,15 +9,15 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.diffdata.impl;
+package org.eclipse.emf.diffmerge.generic.gdiffdata.impl;
 
 import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.diffmerge.api.Role;
-import org.eclipse.emf.diffmerge.api.scopes.IEditableModelScope;
-import org.eclipse.emf.diffmerge.diffdata.DiffdataPackage;
-import org.eclipse.emf.diffmerge.diffdata.EComparison;
-import org.eclipse.emf.diffmerge.diffdata.EElementRelativePresence;
-import org.eclipse.emf.diffmerge.diffdata.EMatch;
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GElementRelativePresence;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
@@ -30,14 +30,15 @@
  * The following features are implemented:
  * </p>
  * <ul>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EElementRelativePresenceImpl#getElementMatch <em>Element Match</em>}</li>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EElementRelativePresenceImpl#getPresenceRole <em>Presence Role</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementRelativePresenceImpl#getElementMatch <em>Element Match</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GElementRelativePresenceImpl#getPresenceRole <em>Presence Role</em>}</li>
  * </ul>
  *
  * @generated
  */
-public abstract class EElementRelativePresenceImpl
-    extends EMergeableDifferenceImpl implements EElementRelativePresence {
+public abstract class GElementRelativePresenceImpl<E, A, R>
+    extends GMergeableDifferenceImpl<E, A, R>
+    implements GElementRelativePresence<E, A, R> {
   /**
    * The cached value of the '{@link #getElementMatch() <em>Element Match</em>}' reference.
    * <!-- begin-user-doc -->
@@ -46,7 +47,7 @@
    * @generated
    * @ordered
    */
-  protected EMatch elementMatch;
+  protected GMatch<E, A, R> elementMatch;
 
   /**
    * The default value of the '{@link #getPresenceRole() <em>Presence Role</em>}' attribute.
@@ -73,21 +74,19 @@
    * <!-- end-user-doc -->
    * @generated
    */
-  protected EElementRelativePresenceImpl() {
+  protected GElementRelativePresenceImpl() {
     super();
   }
 
   /**
    * Constructor
-   * @param comparison_p the non-null comparison to which this difference belongs
    * @param match_p the non-null match to which this difference is relative
    * @param presenceRole_p the role of the presence: TARGET or REFERENCE
    * @generated NOT
    */
-  protected EElementRelativePresenceImpl(EComparison comparison_p,
-      EMatch match_p, Role presenceRole_p) {
+  protected GElementRelativePresenceImpl(GMatch<E, A, R> match_p,
+      Role presenceRole_p) {
     super(false);
-    setComparison(comparison_p);
     setElementMatch(match_p);
     setPresenceRole(presenceRole_p);
   }
@@ -99,7 +98,7 @@
    */
   @Override
   protected EClass eStaticClass() {
-    return DiffdataPackage.Literals.EELEMENT_RELATIVE_PRESENCE;
+    return GdiffdataPackage.Literals.GELEMENT_RELATIVE_PRESENCE;
   }
 
   /**
@@ -107,14 +106,15 @@
    * <!-- end-user-doc -->
    * @generated
    */
-  public EMatch getElementMatch() {
+  @SuppressWarnings("unchecked")
+  public GMatch<E, A, R> getElementMatch() {
     if (elementMatch != null && elementMatch.eIsProxy()) {
       InternalEObject oldElementMatch = (InternalEObject) elementMatch;
-      elementMatch = (EMatch) eResolveProxy(oldElementMatch);
+      elementMatch = (GMatch<E, A, R>) eResolveProxy(oldElementMatch);
       if (elementMatch != oldElementMatch) {
         if (eNotificationRequired())
           eNotify(new ENotificationImpl(this, Notification.RESOLVE,
-              DiffdataPackage.EELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH,
+              GdiffdataPackage.GELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH,
               oldElementMatch, elementMatch));
       }
     }
@@ -126,7 +126,7 @@
    * <!-- end-user-doc -->
    * @generated
    */
-  public EMatch basicGetElementMatch() {
+  public GMatch<E, A, R> basicGetElementMatch() {
     return elementMatch;
   }
 
@@ -135,12 +135,12 @@
    * <!-- end-user-doc -->
    * @generated
    */
-  public void setElementMatch(EMatch newElementMatch) {
-    EMatch oldElementMatch = elementMatch;
+  public void setElementMatch(GMatch<E, A, R> newElementMatch) {
+    GMatch<E, A, R> oldElementMatch = elementMatch;
     elementMatch = newElementMatch;
     if (eNotificationRequired())
       eNotify(new ENotificationImpl(this, Notification.SET,
-          DiffdataPackage.EELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH,
+          GdiffdataPackage.GELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH,
           oldElementMatch, elementMatch));
   }
 
@@ -163,7 +163,7 @@
     presenceRole = newPresenceRole;
     if (eNotificationRequired())
       eNotify(new ENotificationImpl(this, Notification.SET,
-          DiffdataPackage.EELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE,
+          GdiffdataPackage.GELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE,
           oldPresenceRole, presenceRole));
   }
 
@@ -175,11 +175,11 @@
   @Override
   public Object eGet(int featureID, boolean resolve, boolean coreType) {
     switch (featureID) {
-    case DiffdataPackage.EELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH:
+    case GdiffdataPackage.GELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH:
       if (resolve)
         return getElementMatch();
       return basicGetElementMatch();
-    case DiffdataPackage.EELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE:
+    case GdiffdataPackage.GELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE:
       return getPresenceRole();
     }
     return super.eGet(featureID, resolve, coreType);
@@ -190,13 +190,14 @@
    * <!-- end-user-doc -->
    * @generated
    */
+  @SuppressWarnings("unchecked")
   @Override
   public void eSet(int featureID, Object newValue) {
     switch (featureID) {
-    case DiffdataPackage.EELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH:
-      setElementMatch((EMatch) newValue);
+    case GdiffdataPackage.GELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH:
+      setElementMatch((GMatch<E, A, R>) newValue);
       return;
-    case DiffdataPackage.EELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE:
+    case GdiffdataPackage.GELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE:
       setPresenceRole((Role) newValue);
       return;
     }
@@ -211,10 +212,10 @@
   @Override
   public void eUnset(int featureID) {
     switch (featureID) {
-    case DiffdataPackage.EELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH:
-      setElementMatch((EMatch) null);
+    case GdiffdataPackage.GELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH:
+      setElementMatch((GMatch<E, A, R>) null);
       return;
-    case DiffdataPackage.EELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE:
+    case GdiffdataPackage.GELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE:
       setPresenceRole(PRESENCE_ROLE_EDEFAULT);
       return;
     }
@@ -229,9 +230,9 @@
   @Override
   public boolean eIsSet(int featureID) {
     switch (featureID) {
-    case DiffdataPackage.EELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH:
+    case GdiffdataPackage.GELEMENT_RELATIVE_PRESENCE__ELEMENT_MATCH:
       return elementMatch != null;
-    case DiffdataPackage.EELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE:
+    case GdiffdataPackage.GELEMENT_RELATIVE_PRESENCE__PRESENCE_ROLE:
       return PRESENCE_ROLE_EDEFAULT == null ? presenceRole != null
           : !PRESENCE_ROLE_EDEFAULT.equals(presenceRole);
     }
@@ -256,15 +257,16 @@
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.diffdata.impl.EMergeableDifferenceImpl#doMergeIn(org.eclipse.emf.diffmerge.api.Role)
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl#doMergeIn(org.eclipse.emf.diffmerge.generic.api.Role)
    * @generated NOT
    */
   @Override
   public final void doMergeIn(Role destination_p) {
-    if (destination_p == getPresenceRole())
+    if (destination_p == getPresenceRole()) {
       mergeRemoval();
-    else
+    } else {
       mergeAddition();
+    }
   }
 
   /**
@@ -281,20 +283,30 @@
    * @return a non-null scope
    * @generated NOT
    */
-  protected final IEditableModelScope getAbsenceScope() {
-    IEditableModelScope result = getComparison()
+  protected final IEditableTreeDataScope<E> getAbsenceScope() {
+    IEditableTreeDataScope<E> result = getComparison()
         .getScope(getPresenceRole().opposite());
     assert result != null;
     return result;
   }
 
   /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl#getComparison()
+   * @generated NOT
+   */
+  @Override
+  public GComparison<E, A, R> getComparison() {
+    return getElementMatch().getComparison();
+  }
+
+  /**
    * Return the scope of the presence role
    * @return a non-null scope
    * @generated NOT
    */
-  protected final IEditableModelScope getPresenceScope() {
-    IEditableModelScope result = getComparison().getScope(getPresenceRole());
+  public IEditableTreeDataScope<E> getPresenceScope() {
+    IEditableTreeDataScope<E> result = getComparison()
+        .getScope(getPresenceRole());
     assert result != null;
     return result;
   }
@@ -311,4 +323,4 @@
    */
   protected abstract void mergeRemoval();
 
-} //EElementRelativePresenceImpl
+} //GElementRelativePresenceImpl
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/diffdata/impl/EIdentifiedImpl.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GIdentifiedImpl.java
similarity index 69%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/diffdata/impl/EIdentifiedImpl.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GIdentifiedImpl.java
index 234509a..e5f1b80 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/diffdata/impl/EIdentifiedImpl.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GIdentifiedImpl.java
@@ -1,29 +1,38 @@
-/**
- */
-package org.eclipse.emf.diffmerge.diffdata.impl;
+/*********************************************************************
+ * Copyright (c) 2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata.impl;
 
 import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.diffmerge.diffdata.DiffdataPackage;
-import org.eclipse.emf.diffmerge.diffdata.EIdentified;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GIdentified;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
 
 /**
  * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>EIdentified</b></em>'.
+ * An implementation of the model object '<em><b>GIdentified</b></em>'.
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
  * </p>
  * <ul>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EIdentifiedImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GIdentifiedImpl#getId <em>Id</em>}</li>
  * </ul>
  *
  * @generated
  */
-public abstract class EIdentifiedImpl extends EObjectImpl
-    implements EIdentified {
+public abstract class GIdentifiedImpl extends EObjectImpl
+    implements GIdentified {
   /**
    * The default value of the '{@link #getId() <em>Id</em>}' attribute.
    * <!-- begin-user-doc -->
@@ -49,7 +58,7 @@
    * <!-- end-user-doc -->
    * @generated
    */
-  protected EIdentifiedImpl() {
+  protected GIdentifiedImpl() {
     super();
   }
 
@@ -60,7 +69,7 @@
    */
   @Override
   protected EClass eStaticClass() {
-    return DiffdataPackage.Literals.EIDENTIFIED;
+    return GdiffdataPackage.Literals.GIDENTIFIED;
   }
 
   /**
@@ -82,7 +91,7 @@
     id = newId;
     if (eNotificationRequired())
       eNotify(new ENotificationImpl(this, Notification.SET,
-          DiffdataPackage.EIDENTIFIED__ID, oldId, id));
+          GdiffdataPackage.GIDENTIFIED__ID, oldId, id));
   }
 
   /**
@@ -93,7 +102,7 @@
   @Override
   public Object eGet(int featureID, boolean resolve, boolean coreType) {
     switch (featureID) {
-    case DiffdataPackage.EIDENTIFIED__ID:
+    case GdiffdataPackage.GIDENTIFIED__ID:
       return getId();
     }
     return super.eGet(featureID, resolve, coreType);
@@ -107,7 +116,7 @@
   @Override
   public void eSet(int featureID, Object newValue) {
     switch (featureID) {
-    case DiffdataPackage.EIDENTIFIED__ID:
+    case GdiffdataPackage.GIDENTIFIED__ID:
       setId((String) newValue);
       return;
     }
@@ -122,7 +131,7 @@
   @Override
   public void eUnset(int featureID) {
     switch (featureID) {
-    case DiffdataPackage.EIDENTIFIED__ID:
+    case GdiffdataPackage.GIDENTIFIED__ID:
       setId(ID_EDEFAULT);
       return;
     }
@@ -137,7 +146,7 @@
   @Override
   public boolean eIsSet(int featureID) {
     switch (featureID) {
-    case DiffdataPackage.EIDENTIFIED__ID:
+    case GdiffdataPackage.GIDENTIFIED__ID:
       return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
     }
     return super.eIsSet(featureID);
@@ -160,4 +169,4 @@
     return result.toString();
   }
 
-} //EIdentifiedImpl
+} //GIdentifiedImpl
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GMappingImpl.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GMappingImpl.java
new file mode 100644
index 0000000..b5e9514
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GMappingImpl.java
@@ -0,0 +1,575 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata.impl;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.ECollections;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.EMap;
+import org.eclipse.emf.diffmerge.generic.api.IMatch;
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IRawDataScope;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage;
+import org.eclipse.emf.diffmerge.generic.impl.helpers.BidirectionalComparisonCopier;
+import org.eclipse.emf.diffmerge.structures.common.FHashMap;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.EObjectEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>GMapping</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMappingImpl#getModifiableContents <em>Modifiable Contents</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMappingImpl#getReferenceCompletedMatches <em>Reference Completed Matches</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMappingImpl#getTargetCompletedMatches <em>Target Completed Matches</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public abstract class GMappingImpl<E, A, R> extends GIdentifiedImpl
+    implements GMapping<E, A, R> {
+  /**
+   * The cached value of the '{@link #getModifiableContents() <em>Modifiable Contents</em>}' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getModifiableContents()
+   * @generated
+   * @ordered
+   */
+  protected EList<GMatch<E, A, R>> modifiableContents;
+
+  /**
+   * The cached value of the '{@link #getReferenceCompletedMatches() <em>Reference Completed Matches</em>}' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getReferenceCompletedMatches()
+   * @generated
+   * @ordered
+   */
+  protected EList<IMatch<E>> referenceCompletedMatches;
+
+  /**
+   * The cached value of the '{@link #getTargetCompletedMatches() <em>Target Completed Matches</em>}' reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getTargetCompletedMatches()
+   * @generated
+   * @ordered
+   */
+  protected EList<IMatch<E>> targetCompletedMatches;
+
+  /**
+   * A non-null, stateless copier for completing partial matches
+   * @generated NOT
+   */
+  private final BidirectionalComparisonCopier<E> _copier;
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated NOT
+   */
+  protected GMappingImpl() {
+    super();
+    _copier = new BidirectionalComparisonCopier<E>();
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return GdiffdataPackage.Literals.GMAPPING;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public EList<GMatch<E, A, R>> getModifiableContents() {
+    if (modifiableContents == null) {
+      modifiableContents = new EObjectContainmentEList<GMatch<E, A, R>>(
+          GMatch.class, this, GdiffdataPackage.GMAPPING__MODIFIABLE_CONTENTS);
+    }
+    return modifiableContents;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public EList<IMatch<E>> getReferenceCompletedMatches() {
+    if (referenceCompletedMatches == null) {
+      referenceCompletedMatches = new EObjectEList<IMatch<E>>(IMatch.class,
+          this, GdiffdataPackage.GMAPPING__REFERENCE_COMPLETED_MATCHES);
+    }
+    return referenceCompletedMatches;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public EList<IMatch<E>> getTargetCompletedMatches() {
+    if (targetCompletedMatches == null) {
+      targetCompletedMatches = new EObjectEList<IMatch<E>>(IMatch.class, this,
+          GdiffdataPackage.GMAPPING__TARGET_COMPLETED_MATCHES);
+    }
+    return targetCompletedMatches;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd,
+      int featureID, NotificationChain msgs) {
+    switch (featureID) {
+    case GdiffdataPackage.GMAPPING__MODIFIABLE_CONTENTS:
+      return ((InternalEList<?>) getModifiableContents()).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 GdiffdataPackage.GMAPPING__MODIFIABLE_CONTENTS:
+      return getModifiableContents();
+    case GdiffdataPackage.GMAPPING__REFERENCE_COMPLETED_MATCHES:
+      return getReferenceCompletedMatches();
+    case GdiffdataPackage.GMAPPING__TARGET_COMPLETED_MATCHES:
+      return getTargetCompletedMatches();
+    }
+    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 GdiffdataPackage.GMAPPING__MODIFIABLE_CONTENTS:
+      getModifiableContents().clear();
+      getModifiableContents()
+          .addAll((Collection<? extends GMatch<E, A, R>>) newValue);
+      return;
+    case GdiffdataPackage.GMAPPING__REFERENCE_COMPLETED_MATCHES:
+      getReferenceCompletedMatches().clear();
+      getReferenceCompletedMatches()
+          .addAll((Collection<? extends IMatch<E>>) newValue);
+      return;
+    case GdiffdataPackage.GMAPPING__TARGET_COMPLETED_MATCHES:
+      getTargetCompletedMatches().clear();
+      getTargetCompletedMatches()
+          .addAll((Collection<? extends IMatch<E>>) newValue);
+      return;
+    }
+    super.eSet(featureID, newValue);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID) {
+    switch (featureID) {
+    case GdiffdataPackage.GMAPPING__MODIFIABLE_CONTENTS:
+      getModifiableContents().clear();
+      return;
+    case GdiffdataPackage.GMAPPING__REFERENCE_COMPLETED_MATCHES:
+      getReferenceCompletedMatches().clear();
+      return;
+    case GdiffdataPackage.GMAPPING__TARGET_COMPLETED_MATCHES:
+      getTargetCompletedMatches().clear();
+      return;
+    }
+    super.eUnset(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID) {
+    switch (featureID) {
+    case GdiffdataPackage.GMAPPING__MODIFIABLE_CONTENTS:
+      return modifiableContents != null && !modifiableContents.isEmpty();
+    case GdiffdataPackage.GMAPPING__REFERENCE_COMPLETED_MATCHES:
+      return referenceCompletedMatches != null
+          && !referenceCompletedMatches.isEmpty();
+    case GdiffdataPackage.GMAPPING__TARGET_COMPLETED_MATCHES:
+      return targetCompletedMatches != null
+          && !targetCompletedMatches.isEmpty();
+    }
+    return super.eIsSet(featureID);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping.Editable#clear()
+   * @generated NOT
+   */
+  public void clear() {
+    getModifiableContents().clear();
+    getTargetCompletedMatches().clear();
+    getReferenceCompletedMatches().clear();
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping.Editable#completeMatch(org.eclipse.emf.diffmerge.generic.api.IMatch)
+   * @generated NOT
+   */
+  public E completeMatch(IMatch<E> partialMatch_p) {
+    return _copier.completeMatch(this, partialMatch_p);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping.Editable#completeReferences(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public void completeReferences(Role role_p) {
+    _copier.completeReferences(this, role_p);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#covers(java.lang.Object, org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public boolean covers(E element_p, Role role_p) {
+    return getMatchFor(element_p, role_p) != null;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#getCompletedMatches(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public Collection<IMatch<E>> getCompletedMatches(Role destinationRole_p) {
+    return Collections.unmodifiableCollection(
+        getModifiableCompletedMatches(destinationRole_p));
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement#getComparison()
+   * @generated OT
+   */
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  public GComparison<E, A, R> getComparison() {
+    GComparison<E, A, R> result = null;
+    EObject container = eContainer();
+    if (container instanceof GComparison) {
+      result = (GComparison) container;
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#getContents()
+   * @generated NOT
+   */
+  public Collection<IMatch<E>> getContents() {
+    return Collections
+        .<IMatch<E>> unmodifiableCollection(getModifiableContents());
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping.Editable#getModifiableCompletedMatches(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public Collection<IMatch<E>> getModifiableCompletedMatches(
+      Role destinationRole_p) {
+    return Role.TARGET == destinationRole_p ? getTargetCompletedMatches()
+        : getReferenceCompletedMatches();
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#getNbFullMatches()
+   * @generated NOT
+   */
+  public int getNbFullMatches() {
+    int result = 0;
+    for (IMatch<E> match : getContents())
+      if (!match.isPartial())
+        result++;
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#getNbPartialMatches(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public int getNbPartialMatches(Role covered_p) {
+    int result = 0;
+    for (IMatch<E> match : getContents())
+      if (match.isPartial()
+          && (covered_p == null || match.coversRole(covered_p)))
+        result++;
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#getOrderingRole()
+   * @generated NOT
+   */
+  public Role getOrderingRole() {
+    return Role.TARGET;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#isCompleteFor(org.eclipse.emf.diffmerge.generic.api.scopes.IRawDataScope, org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public boolean isCompleteFor(IRawDataScope<E> scope_p, Role role_p) {
+    Iterator<E> it = scope_p.iterator();
+    while (it.hasNext()) {
+      E currentInScope = it.next();
+      if (!covers(currentInScope, role_p))
+        return false;
+    }
+    return true;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#isEmpty()
+   * @generated NOT
+   */
+  public boolean isEmpty() {
+    return getModifiableContents().isEmpty();
+  }
+
+  /**
+   * Return whether the given reference value on the given side is ignored due to
+   * being between partial matches
+   * @param source_p a non-null element
+   * @param reference_p a non-null reference
+   * @param value_p a non-null element
+   * @param role_p a non-null role
+   * @generated NOT
+   */
+  public boolean isIgnoredReferenceValue(E source_p, R reference_p, E value_p,
+      Role role_p) {
+    boolean result = false;
+    IMatch<E> referencingMatch = getMatchFor(source_p, role_p);
+    IMatch<E> referencedMatch = getMatchFor(value_p, role_p);
+    // References between unmatched elements
+    if (referencingMatch != null && referencedMatch != null) {
+      result = referencingMatch.isPartial() && referencedMatch.isPartial();
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping#disconnect(org.eclipse.emf.diffmerge.generic.api.Role, java.lang.Object)
+   * @generated NOT
+   */
+  public boolean disconnect(Role role_p, E element_p) {
+    boolean result = true;
+    IEditableTreeDataScope<E> scope = getComparison().getScope(role_p);
+    if (scope.tIsElementDisconnectionRequired()) {
+      result = doDisconnect(role_p, element_p);
+    }
+    return result;
+  }
+
+  /**
+   * Remove dependencies (reference values) to the given element so that its removal
+   * from the scope of the given role be possible, as required by the scope.
+   * Precondition: getComparison().getScope(role_p).tIsElementDisconnectionRequired()
+   * @see GMapping#disconnect(Role, Object)
+   * @generated NOT
+   */
+  protected abstract boolean doDisconnect(Role role_p, E element_p);
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping#map(java.lang.Object, org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public GMatch<E, A, R> map(E element_p, Role role_p) {
+    assert element_p != null && role_p != null;
+    IMatch<E> previous = getMatchFor(element_p, role_p);
+    // Enforce consistency by removing previous match if any
+    if (previous != null) {
+      getModifiableContents().remove(previous);
+    }
+    @SuppressWarnings("unchecked")
+    GMatch<E, A, R> result = (GMatch<E, A, R>) getComparison().newMatch(
+        (Role.TARGET == role_p ? element_p : null),
+        (Role.REFERENCE == role_p ? element_p : null),
+        (Role.ANCESTOR == role_p ? element_p : null));
+    getModifiableContents().add(result);
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping.Editable#mapIncrementally(Object, org.eclipse.emf.diffmerge.generic.api.Role, Object, org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  public boolean mapIncrementally(E element1_p, Role role1_p, E element2_p,
+      Role role2_p) {
+    assert role1_p != null && role2_p != null && role1_p != role2_p;
+    IMatch<E> newMatch = null;
+    boolean result = false;
+    Map<Role, E> elements = new HashMap<Role, E>(3);
+    elements.put(role1_p, element1_p);
+    elements.put(role2_p, element2_p);
+    Role role3 = Role.otherThan(role1_p, role2_p);
+    E element3 = null;
+    // Checking existing match in role1_p
+    if (element1_p != null) {
+      newMatch = getMatchFor(element1_p, role1_p);
+      if (newMatch != null) {
+        element3 = newMatch.get(role3);
+        E foundElement2 = newMatch.get(role2_p);
+        result = foundElement2 != null && foundElement2 != element2_p;
+      }
+    }
+    // Checking existing match in role2_p
+    if (element2_p != null) {
+      IMatch<E> found = getMatchFor(element2_p, role2_p);
+      if (found != null) {
+        E foundElement1 = found.get(role1_p);
+        result = result || foundElement1 != null && foundElement1 != element1_p;
+        E inRole3 = found.get(role3);
+        if (inRole3 != null) {
+          element3 = inRole3;
+        }
+        // Match found for role2_p which is different from that of role1_p
+        if (newMatch != null && newMatch != found) {
+          getModifiableContents().remove(found);
+        } else {
+          newMatch = found;
+        }
+      }
+    }
+    elements.put(role3, element3);
+    if (newMatch == null) {
+      newMatch = getComparison().newMatch(elements.get(Role.TARGET),
+          elements.get(Role.REFERENCE), elements.get(Role.ANCESTOR));
+      // We assume the type of the match is compatible with the mapping
+      getModifiableContents().add((GMatch) newMatch);
+    } else {
+      ((IMatch.Editable) newMatch).reset(elements.get(Role.TARGET),
+          elements.get(Role.REFERENCE), elements.get(Role.ANCESTOR));
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#maps(Object, Object)
+   * @generated NOT
+   */
+  public boolean maps(E target_p, E reference_p) {
+    return maps(target_p, Role.TARGET, reference_p, Role.REFERENCE);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#maps(Object, Object, Object)
+   * @generated NOT
+   */
+  public boolean maps(E target_p, E reference_p, E ancestor_p) {
+    return maps(ancestor_p, Role.ANCESTOR, target_p, Role.TARGET)
+        && maps(ancestor_p, Role.ANCESTOR, reference_p, Role.REFERENCE)
+        && maps(target_p, Role.TARGET, reference_p, Role.REFERENCE);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#maps(Object, org.eclipse.emf.diffmerge.generic.api.Role, Object, org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public boolean maps(E element1_p, Role role1_p, E element2_p, Role role2_p) {
+    boolean result = false;
+    if (element1_p != null) {
+      IMatch<E> fromElement1 = getMatchFor(element1_p, role1_p);
+      result = fromElement1 != null && fromElement1.get(role2_p) == element2_p;
+    } else if (element2_p != null) {
+      IMatch<E> fromElement2 = getMatchFor(element2_p, role2_p);
+      result = fromElement2 != null && fromElement2.get(role1_p) == element1_p;
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#size()
+   * @generated NOT
+   */
+  public int size() {
+    return getContents().size();
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#size(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public int size(Role role_p) {
+    int result = 0;
+    for (GMatch<E, A, R> match : getModifiableContents()) {
+      if (match.get(role_p) != null)
+        result++;
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMapping#toMap(org.eclipse.emf.diffmerge.generic.api.Role, org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public EMap<E, E> toMap(Role keyRole_p, Role valueRole_p) {
+    EMap<E, E> result = new FHashMap<E, E>();
+    for (IMatch<E> match : getContents()) {
+      E key = match.get(keyRole_p);
+      if (key != null) {
+        result.put(key, match.get(valueRole_p));
+      }
+    }
+    return ECollections.unmodifiableEMap(result);
+  }
+
+} //GMappingImpl
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GMatchImpl.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GMatchImpl.java
new file mode 100644
index 0000000..6aeb72d
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GMatchImpl.java
@@ -0,0 +1,1070 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata.impl;
+
+import static org.eclipse.emf.diffmerge.generic.api.Role.ANCESTOR;
+import static org.eclipse.emf.diffmerge.generic.api.Role.REFERENCE;
+import static org.eclipse.emf.diffmerge.generic.api.Role.TARGET;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+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.common.util.EMap;
+import org.eclipse.emf.diffmerge.generic.api.IMatch;
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.diff.IAttributeValuePresence;
+import org.eclipse.emf.diffmerge.generic.api.diff.IDifference;
+import org.eclipse.emf.diffmerge.generic.api.diff.IElementPresence;
+import org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativeDifference;
+import org.eclipse.emf.diffmerge.generic.api.diff.IPresenceDifference;
+import org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMapping;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage;
+import org.eclipse.emf.diffmerge.structures.common.FArrayList;
+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.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>GMatch</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMatchImpl#getMatchID <em>Match ID</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMatchImpl#getModifiableRelatedDifferences <em>Modifiable Related Differences</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMatchImpl#getElementPresenceDifference <em>Element Presence Difference</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMatchImpl#getReferenceOwnershipDifference <em>Reference Ownership Difference</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMatchImpl#getTargetOwnershipDifference <em>Target Ownership Difference</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public abstract class GMatchImpl<E, A, R> extends GIdentifiedImpl
+    implements GMatch<E, A, R> {
+
+  /**
+   * The default value of the '{@link #getMatchID() <em>Match ID</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getMatchID()
+   * @generated
+   * @ordered
+   */
+  protected static final Object MATCH_ID_EDEFAULT = null;
+
+  /**
+   * The cached value of the '{@link #getMatchID() <em>Match ID</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getMatchID()
+   * @generated
+   * @ordered
+   */
+  protected Object matchID = MATCH_ID_EDEFAULT;
+
+  /**
+   * The cached value of the '{@link #getModifiableRelatedDifferences() <em>Modifiable Related Differences</em>}' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getModifiableRelatedDifferences()
+   * @generated
+   * @ordered
+   */
+  protected EList<GMergeableDifference<E, A, R>> modifiableRelatedDifferences;
+
+  /**
+   * The cached value of the '{@link #getElementPresenceDifference() <em>Element Presence Difference</em>}' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getElementPresenceDifference()
+   * @generated
+   * @ordered
+   */
+  protected IElementPresence<E> elementPresenceDifference;
+
+  /**
+   * The cached value of the '{@link #getReferenceOwnershipDifference() <em>Reference Ownership Difference</em>}' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getReferenceOwnershipDifference()
+   * @generated
+   * @ordered
+   */
+  protected IReferenceValuePresence<E> referenceOwnershipDifference;
+
+  /**
+   * The cached value of the '{@link #getTargetOwnershipDifference() <em>Target Ownership Difference</em>}' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getTargetOwnershipDifference()
+   * @generated
+   * @ordered
+   */
+  protected IReferenceValuePresence<E> targetOwnershipDifference;
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected GMatchImpl() {
+    super();
+  }
+
+  /**
+   * Constructor
+   * Precondition: at least one of the given elements is not null.
+   * @param target_p the optional element on the TARGET side
+   * @param reference_p the optional element on the REFERENCE side
+   * @param ancestor_p the optional element on the ANCESTOR side
+   * @generated NOT
+   */
+  public GMatchImpl(E target_p, E reference_p, E ancestor_p) {
+    this();
+    setTarget(target_p);
+    setReference(reference_p);
+    setAncestor(ancestor_p);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return GdiffdataPackage.Literals.GMATCH;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public Object getMatchID() {
+    return matchID;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setMatchID(Object newMatchID) {
+    Object oldMatchID = matchID;
+    matchID = newMatchID;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GMATCH__MATCH_ID, oldMatchID, matchID));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public EList<GMergeableDifference<E, A, R>> getModifiableRelatedDifferences() {
+    if (modifiableRelatedDifferences == null) {
+      modifiableRelatedDifferences = new EObjectContainmentEList<GMergeableDifference<E, A, R>>(
+          GMergeableDifference.class, this,
+          GdiffdataPackage.GMATCH__MODIFIABLE_RELATED_DIFFERENCES);
+    }
+    return modifiableRelatedDifferences;
+  }
+
+  /**
+   * @see GMatch#getMapping()
+   * @generated NOT
+   */
+  @SuppressWarnings("unchecked")
+  public GMapping<E, A, R> getMapping() {
+    GMapping<E, A, R> result = null;
+    EObject container = eContainer();
+    if (container instanceof GMapping) {
+      result = (GMapping<E, A, R>) container;
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getAncestor()
+   * @generated NOT
+   */
+  public abstract E getAncestor();
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getReference()
+   * @generated NOT
+   */
+  public abstract E getReference();
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#getTarget()
+   * @generated NOT
+   */
+  public abstract E getTarget();
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#setAncestor(java.lang.Object)
+   * @generated NOT
+   */
+  public abstract void setAncestor(E e);
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#setReference(java.lang.Object)
+   * @generated NOT
+   */
+  public abstract void setReference(E e);
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch#setTarget(java.lang.Object)
+   * @generated NOT
+   */
+  public abstract void setTarget(E e);
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement#getComparison()
+   * @generated NOT
+   */
+  public GComparison<E, A, R> getComparison() {
+    GComparison<E, A, R> result = null;
+    GMapping<E, A, R> mapping = getMapping();
+    if (mapping != null) {
+      result = mapping.getComparison();
+    }
+    return result;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  public IElementPresence<E> getElementPresenceDifference() {
+    if (elementPresenceDifference != null
+        && ((EObject) elementPresenceDifference).eIsProxy()) {
+      InternalEObject oldElementPresenceDifference = (InternalEObject) elementPresenceDifference;
+      elementPresenceDifference = (IElementPresence<E>) eResolveProxy(
+          oldElementPresenceDifference);
+      if (elementPresenceDifference != oldElementPresenceDifference) {
+        if (eNotificationRequired())
+          eNotify(new ENotificationImpl(this, Notification.RESOLVE,
+              GdiffdataPackage.GMATCH__ELEMENT_PRESENCE_DIFFERENCE,
+              oldElementPresenceDifference, elementPresenceDifference));
+      }
+    }
+    return elementPresenceDifference;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public IElementPresence<E> basicGetElementPresenceDifference() {
+    return elementPresenceDifference;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setElementPresenceDifference(
+      IElementPresence<E> newElementPresenceDifference) {
+    IElementPresence<E> oldElementPresenceDifference = elementPresenceDifference;
+    elementPresenceDifference = newElementPresenceDifference;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GMATCH__ELEMENT_PRESENCE_DIFFERENCE,
+          oldElementPresenceDifference, elementPresenceDifference));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  public IReferenceValuePresence<E> getReferenceOwnershipDifference() {
+    if (referenceOwnershipDifference != null
+        && ((EObject) referenceOwnershipDifference).eIsProxy()) {
+      InternalEObject oldReferenceOwnershipDifference = (InternalEObject) referenceOwnershipDifference;
+      referenceOwnershipDifference = (IReferenceValuePresence<E>) eResolveProxy(
+          oldReferenceOwnershipDifference);
+      if (referenceOwnershipDifference != oldReferenceOwnershipDifference) {
+        if (eNotificationRequired())
+          eNotify(new ENotificationImpl(this, Notification.RESOLVE,
+              GdiffdataPackage.GMATCH__REFERENCE_OWNERSHIP_DIFFERENCE,
+              oldReferenceOwnershipDifference, referenceOwnershipDifference));
+      }
+    }
+    return referenceOwnershipDifference;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public IReferenceValuePresence<E> basicGetReferenceOwnershipDifference() {
+    return referenceOwnershipDifference;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setReferenceOwnershipDifference(
+      IReferenceValuePresence<E> newReferenceOwnershipDifference) {
+    IReferenceValuePresence<E> oldReferenceOwnershipDifference = referenceOwnershipDifference;
+    referenceOwnershipDifference = newReferenceOwnershipDifference;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GMATCH__REFERENCE_OWNERSHIP_DIFFERENCE,
+          oldReferenceOwnershipDifference, referenceOwnershipDifference));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  public IReferenceValuePresence<E> getTargetOwnershipDifference() {
+    if (targetOwnershipDifference != null
+        && ((EObject) targetOwnershipDifference).eIsProxy()) {
+      InternalEObject oldTargetOwnershipDifference = (InternalEObject) targetOwnershipDifference;
+      targetOwnershipDifference = (IReferenceValuePresence<E>) eResolveProxy(
+          oldTargetOwnershipDifference);
+      if (targetOwnershipDifference != oldTargetOwnershipDifference) {
+        if (eNotificationRequired())
+          eNotify(new ENotificationImpl(this, Notification.RESOLVE,
+              GdiffdataPackage.GMATCH__TARGET_OWNERSHIP_DIFFERENCE,
+              oldTargetOwnershipDifference, targetOwnershipDifference));
+      }
+    }
+    return targetOwnershipDifference;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public IReferenceValuePresence<E> basicGetTargetOwnershipDifference() {
+    return targetOwnershipDifference;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setTargetOwnershipDifference(
+      IReferenceValuePresence<E> newTargetOwnershipDifference) {
+    IReferenceValuePresence<E> oldTargetOwnershipDifference = targetOwnershipDifference;
+    targetOwnershipDifference = newTargetOwnershipDifference;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GMATCH__TARGET_OWNERSHIP_DIFFERENCE,
+          oldTargetOwnershipDifference, targetOwnershipDifference));
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd,
+      int featureID, NotificationChain msgs) {
+    switch (featureID) {
+    case GdiffdataPackage.GMATCH__MODIFIABLE_RELATED_DIFFERENCES:
+      return ((InternalEList<?>) getModifiableRelatedDifferences())
+          .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 GdiffdataPackage.GMATCH__MATCH_ID:
+      return getMatchID();
+    case GdiffdataPackage.GMATCH__MODIFIABLE_RELATED_DIFFERENCES:
+      return getModifiableRelatedDifferences();
+    case GdiffdataPackage.GMATCH__ELEMENT_PRESENCE_DIFFERENCE:
+      if (resolve)
+        return getElementPresenceDifference();
+      return basicGetElementPresenceDifference();
+    case GdiffdataPackage.GMATCH__REFERENCE_OWNERSHIP_DIFFERENCE:
+      if (resolve)
+        return getReferenceOwnershipDifference();
+      return basicGetReferenceOwnershipDifference();
+    case GdiffdataPackage.GMATCH__TARGET_OWNERSHIP_DIFFERENCE:
+      if (resolve)
+        return getTargetOwnershipDifference();
+      return basicGetTargetOwnershipDifference();
+    }
+    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 GdiffdataPackage.GMATCH__MATCH_ID:
+      setMatchID(newValue);
+      return;
+    case GdiffdataPackage.GMATCH__MODIFIABLE_RELATED_DIFFERENCES:
+      getModifiableRelatedDifferences().clear();
+      getModifiableRelatedDifferences().addAll(
+          (Collection<? extends GMergeableDifference<E, A, R>>) newValue);
+      return;
+    case GdiffdataPackage.GMATCH__ELEMENT_PRESENCE_DIFFERENCE:
+      setElementPresenceDifference((IElementPresence<E>) newValue);
+      return;
+    case GdiffdataPackage.GMATCH__REFERENCE_OWNERSHIP_DIFFERENCE:
+      setReferenceOwnershipDifference((IReferenceValuePresence<E>) newValue);
+      return;
+    case GdiffdataPackage.GMATCH__TARGET_OWNERSHIP_DIFFERENCE:
+      setTargetOwnershipDifference((IReferenceValuePresence<E>) newValue);
+      return;
+    }
+    super.eSet(featureID, newValue);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID) {
+    switch (featureID) {
+    case GdiffdataPackage.GMATCH__MATCH_ID:
+      setMatchID(MATCH_ID_EDEFAULT);
+      return;
+    case GdiffdataPackage.GMATCH__MODIFIABLE_RELATED_DIFFERENCES:
+      getModifiableRelatedDifferences().clear();
+      return;
+    case GdiffdataPackage.GMATCH__ELEMENT_PRESENCE_DIFFERENCE:
+      setElementPresenceDifference((IElementPresence<E>) null);
+      return;
+    case GdiffdataPackage.GMATCH__REFERENCE_OWNERSHIP_DIFFERENCE:
+      setReferenceOwnershipDifference((IReferenceValuePresence<E>) null);
+      return;
+    case GdiffdataPackage.GMATCH__TARGET_OWNERSHIP_DIFFERENCE:
+      setTargetOwnershipDifference((IReferenceValuePresence<E>) null);
+      return;
+    }
+    super.eUnset(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID) {
+    switch (featureID) {
+    case GdiffdataPackage.GMATCH__MATCH_ID:
+      return MATCH_ID_EDEFAULT == null ? matchID != null
+          : !MATCH_ID_EDEFAULT.equals(matchID);
+    case GdiffdataPackage.GMATCH__MODIFIABLE_RELATED_DIFFERENCES:
+      return modifiableRelatedDifferences != null
+          && !modifiableRelatedDifferences.isEmpty();
+    case GdiffdataPackage.GMATCH__ELEMENT_PRESENCE_DIFFERENCE:
+      return elementPresenceDifference != null;
+    case GdiffdataPackage.GMATCH__REFERENCE_OWNERSHIP_DIFFERENCE:
+      return referenceOwnershipDifference != null;
+    case GdiffdataPackage.GMATCH__TARGET_OWNERSHIP_DIFFERENCE:
+      return targetOwnershipDifference != null;
+    }
+    return super.eIsSet(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString() {
+    if (eIsProxy())
+      return super.toString();
+
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (matchID: "); //$NON-NLS-1$
+    result.append(matchID);
+    result.append(')');
+    return result.toString();
+  }
+
+  /**
+   * Register the given attribute value presence for fast retrieval
+   * @param presence_p a non-null difference representing a value presence
+   *        which is such that presence_p.getElementMatch() == this
+   * @generated NOT
+   */
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  protected void addAttributeValuePresence(
+      IAttributeValuePresence<E> presence_p) {
+    EMap<A, EList<IAttributeValuePresence<E>>> attributeMap = (EMap) getModifiableAttributeMap(
+        true);
+    EList<IAttributeValuePresence<E>> forAttribute = attributeMap
+        .get(presence_p.getFeature());
+    if (forAttribute == null) {
+      forAttribute = newAttributeValuePresenceList((A) presence_p.getFeature());
+    }
+    forAttribute.add(presence_p);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch.Editable#addOwnershipDifference(org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence)
+   * @generated NOT
+   */
+  public void addOwnershipDifference(IReferenceValuePresence<E> presence_p) {
+    if (Role.TARGET == presence_p.getPresenceRole()) {
+      setTargetOwnershipDifference(presence_p);
+    } else {
+      setReferenceOwnershipDifference(presence_p);
+    }
+  }
+
+  /**
+   * Register the given order difference for fast retrieval
+   * @param presence_p a non-null difference representing a value presence
+   *        which is such that presence_p.getElementMatch() == this
+   *        and isOrder() is true
+   * @generated NOT
+   */
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  protected void addReferenceOrderDifference(
+      IReferenceValuePresence<E> presence_p) {
+    assert presence_p.getElementMatch() == this && presence_p.isOrder();
+    EMap<R, EList<IReferenceValuePresence<E>>> referenceMap = (EMap) getModifiableOrderReferenceMap(
+        true);
+    List<IReferenceValuePresence<E>> forReference = referenceMap
+        .get(presence_p.getFeature());
+    if (forReference == null) {
+      forReference = newReferenceOrderDifferenceList(
+          (R) presence_p.getFeature());
+    }
+    forReference.add(presence_p);
+  }
+
+  /**
+   * Register the given non-order reference value presence for fast retrieval
+   * @param presence_p a non-null difference representing a value presence
+   *        which is such that presence_p.getElementMatch() == this
+   * @generated NOT
+   */
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  protected void addReferenceValuePresence(
+      IReferenceValuePresence<E> presence_p) {
+    assert presence_p.getElementMatch() == this && !presence_p.isOrder();
+    EMap<R, EMap<E, IReferenceValuePresence<E>>> referenceMap = (EMap) getModifiableReferenceMap(
+        true);
+    EMap<E, IReferenceValuePresence<E>> forReference = referenceMap
+        .get(presence_p.getFeature());
+    if (forReference == null) {
+      forReference = newReferenceValueToPresenceMap(
+          (R) presence_p.getFeature());
+    }
+    E key = presence_p.getValue();
+    forReference.put(key, presence_p); // key cannot be null
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch.Editable#addRelatedDifference(org.eclipse.emf.diffmerge.generic.api.diff.IDifference)
+   * @generated NOT
+   */
+  @SuppressWarnings("unchecked")
+  public void addRelatedDifference(IDifference<E> difference_p) {
+    assert difference_p != null;
+    Collection<? extends IDifference<E>> differences = getModifiableRelatedDifferences(
+        true);
+    if (!differences.contains(difference_p)) {
+      ((Collection<IDifference<E>>) differences).add(difference_p); // Difference is supposed compatible
+      if (difference_p instanceof IElementPresence) {
+        setElementPresenceDifference((IElementPresence<E>) difference_p);
+      } else if (difference_p instanceof IReferenceValuePresence) {
+        IReferenceValuePresence<E> presence = (IReferenceValuePresence<E>) difference_p;
+        if (presence.isOrder()) {
+          // Order ref difference
+          addReferenceOrderDifference(presence);
+        } else {
+          // Non-order ref difference
+          addReferenceValuePresence(presence);
+          // If relevant, register implicit universal container reference on value
+          if (presence.isOwnership()) {
+            IMatch<E> valueMatch = presence.getValueMatch();
+            if (valueMatch != null) {
+              ((IMatch.Editable<E>) valueMatch)
+                  .addOwnershipDifference(presence);
+            }
+          }
+        }
+      } else if (difference_p instanceof IAttributeValuePresence<?>) {
+        addAttributeValuePresence((IAttributeValuePresence<E>) difference_p);
+      }
+    }
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IPureMatch#coversRole(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public boolean coversRole(Role role_p) {
+    return get(role_p) != null;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IPureMatch#get(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public E get(Role role_p) {
+    E result;
+    switch (role_p) {
+    case TARGET:
+      result = getTarget();
+      break;
+    case REFERENCE:
+      result = getReference();
+      break;
+    default:
+      result = getAncestor();
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getAllDifferences()
+   * @generated NOT
+   */
+  public List<IDifference<E>> getAllDifferences() {
+    List<IDifference<E>> result = new FArrayList<IDifference<E>>(
+        getRelatedDifferences(), null);
+    IDifference<E> targetOwnership = getOwnershipDifference(Role.TARGET);
+    if (targetOwnership != null) {
+      result.add(targetOwnership);
+    }
+    IDifference<E> referenceOwnership = getOwnershipDifference(Role.REFERENCE);
+    if (referenceOwnership != null) {
+      result.add(referenceOwnership);
+    }
+    return Collections.unmodifiableList(result);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getAttributeDifferences(java.lang.Object)
+   * @generated NOT
+   */
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  public Collection<IAttributeValuePresence<E>> getAttributeDifferences(
+      Object attribute_p) {
+    Collection<IAttributeValuePresence<E>> result = null;
+    if (getModifiableAttributeMap(false) != null) {
+      EList<IAttributeValuePresence<E>> forAttribute = (EList) getModifiableAttributeMap(
+          false).get(attribute_p);
+      if (forAttribute != null) {
+        result = Collections.unmodifiableCollection(forAttribute);
+      }
+    }
+    if (result == null) {
+      result = Collections.emptyList();
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getAttributeOrderDifference(java.lang.Object, org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  public IAttributeValuePresence<E> getAttributeOrderDifference(
+      Object attribute_p, Role role_p) {
+    IAttributeValuePresence<E> result = null;
+    EMap<A, EList<IAttributeValuePresence<E>>> attributeMap = (EMap) getModifiableAttributeMap(
+        false);
+    if (attributeMap != null) {
+      List<IAttributeValuePresence<E>> forAttribute = attributeMap
+          .get(attribute_p);
+      if (forAttribute != null) {
+        for (IAttributeValuePresence<E> current : forAttribute) {
+          if (current.isOrder() && current.getPresenceRole() == role_p) {
+            result = current;
+            break;
+          }
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getAttributeValueDifference(java.lang.Object, java.lang.Object)
+   * @generated NOT
+   */
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  public IAttributeValuePresence<E> getAttributeValueDifference(
+      Object attribute_p, Object value_p) {
+    IAttributeValuePresence<E> result = null;
+    if (getModifiableAttributeMap(false) != null) {
+      List<IAttributeValuePresence<E>> forAttribute = (List) getModifiableAttributeMap(
+          false).get(attribute_p);
+      if (forAttribute != null) {
+        for (IAttributeValuePresence<E> current : forAttribute) {
+          if (value_p.equals(current.getValue())) {
+            result = current;
+            break;
+          }
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getAttributesWithDifferences()
+   * @generated NOT
+   */
+  public Collection<Object> getAttributesWithDifferences() {
+    Set<Object> result;
+    if (getModifiableAttributeMap(false) == null) {
+      result = Collections.emptySet();
+    } else {
+      result = Collections
+          .unmodifiableSet(getModifiableAttributeMap(false).keySet());
+    }
+    return result;
+  }
+
+  /**
+   * Return the double map: attribute -> value -> difference.
+   * Return type should be EMap<A, EList<IAttributeValuePresence<E>>> but EMF code gen
+   * does not fully support type arguments on maps.
+   * @param create_p whether the map must be created if it does not exist
+   * @return a modifiable map which is not null if create_p
+   * @generated NOT
+   */
+  protected abstract EMap<?, ? extends EList<? extends IAttributeValuePresence<?>>> getModifiableAttributeMap(
+      boolean create_p);
+
+  /**
+   * Return the reference -> order differences map.
+   * Return type should be EMap<R, EList<IReferenceValuePresence<E>>> but EMF code gen
+   * does not fully support type arguments on maps.
+   * @param create_p whether the map must be created if it does not exist
+   * @return a modifiable map which is not null if create_p
+   * @generated NOT
+   */
+  protected abstract EMap<?, ? extends EList<? extends IReferenceValuePresence<?>>> getModifiableOrderReferenceMap(
+      boolean create_p);
+
+  /**
+   * Return the double map: reference -> value -> difference.
+   * Return type should be EMap<R, EMap<E, IReferenceValuePresence<E>>> but EMF code gen
+   * does not fully support type arguments on maps.
+   * @param create_p whether the map must be created if it does not exist
+   * @return a modifiable map which is not null if create_p
+   * @generated NOT
+   */
+  protected abstract EMap<?, ? extends EMap<?, ? extends IReferenceValuePresence<?>>> getModifiableReferenceMap(
+      boolean create_p);
+
+  /**
+   * Return the related differences as a modifiable collection
+   * @param create_p whether the collection must be created if it does not exist
+   * @return a modifiable collection which is not null if create_p
+   * @generated NOT
+   */
+  protected List<GMergeableDifference<E, A, R>> getModifiableRelatedDifferences(
+      boolean create_p) {
+    return create_p ? getModifiableRelatedDifferences()
+        : modifiableRelatedDifferences;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getNbNoContainmentDifferences()
+   * @generated NOT
+   */
+  public int getNbNoContainmentDifferences() {
+    int result = 0;
+    if (!isPartial()) {
+      for (IDifference<E> difference : getRelatedDifferences()) {
+        if (difference instanceof IElementRelativeDifference
+            && ((IElementRelativeDifference<E>) difference)
+                .isUnrelatedToContainmentTree()
+            && !difference.isMerged()) {
+          result++;
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getOwnershipDifference(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public IReferenceValuePresence<E> getOwnershipDifference(Role role_p) {
+    return (Role.TARGET == role_p) ? getTargetOwnershipDifference()
+        : getReferenceOwnershipDifference();
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getPresenceDifferencesIn(org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public Collection<IDifference<E>> getPresenceDifferencesIn(Role role_p) {
+    Collection<IDifference<E>> result = new ArrayList<IDifference<E>>();
+    for (IDifference<E> difference : getRelatedDifferences()) {
+      if (difference instanceof IPresenceDifference
+          && ((IPresenceDifference<E>) difference)
+              .getPresenceRole() == role_p) {
+        result.add(difference);
+      }
+    }
+    return Collections.unmodifiableCollection(result);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getReferenceDifferences(java.lang.Object)
+   * @generated NOT
+   */
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  public Collection<IReferenceValuePresence<E>> getReferenceDifferences(
+      Object reference_p) {
+    Collection<IReferenceValuePresence<E>> result = null;
+    if (getModifiableReferenceMap(false) != null) {
+      EMap<E, IReferenceValuePresence<E>> forReference = (EMap) getModifiableReferenceMap(
+          false).get(reference_p);
+      if (forReference != null) {
+        result = Collections.unmodifiableCollection(forReference.values());
+      }
+    }
+    if (result == null) {
+      result = Collections.emptyList();
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getReferenceOrderDifference(java.lang.Object, org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  public IReferenceValuePresence<E> getReferenceOrderDifference(
+      Object reference_p, Role role_p) {
+    EMap<R, EList<IReferenceValuePresence<E>>> referenceMap = (EMap) getModifiableOrderReferenceMap(
+        false);
+    if (referenceMap != null) {
+      List<IReferenceValuePresence<E>> forReference = referenceMap
+          .get(reference_p);
+      for (IReferenceValuePresence<E> orderDifference : forReference) {
+        if (orderDifference.getPresenceRole() == role_p) {
+          return orderDifference;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getReferenceValueDifference(java.lang.Object, java.lang.Object)
+   * @generated NOT
+   */
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  public IReferenceValuePresence<E> getReferenceValueDifference(
+      Object reference_p, E value_p) {
+    IReferenceValuePresence<E> result = null;
+    if (getModifiableReferenceMap(false) != null) {
+      EMap<E, IReferenceValuePresence<E>> forReference = (EMap) getModifiableReferenceMap(
+          false).get(reference_p);
+      if (forReference != null) {
+        result = forReference.get(value_p);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getReferencesWithDifferences()
+   * @generated NOT
+   */
+  public Collection<Object> getReferencesWithDifferences() {
+    Set<Object> result;
+    if (getModifiableReferenceMap(false) == null) {
+      result = Collections.emptySet();
+    } else {
+      result = Collections
+          .unmodifiableSet(getModifiableReferenceMap(false).keySet());
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#getRelatedDifferences()
+   * @generated NOT
+   */
+  public List<IDifference<E>> getRelatedDifferences() {
+    List<IDifference<E>> result;
+    List<GMergeableDifference<E, A, R>> modifiable = getModifiableRelatedDifferences(
+        false);
+    if (modifiable == null) {
+      result = Collections.emptyList();
+    } else {
+      result = Collections.<IDifference<E>> unmodifiableList(modifiable);
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IPureMatch#getUncoveredRole()
+   * @generated NOT
+   */
+  public Role getUncoveredRole() {
+    Role result = null;
+    if (!coversRole(TARGET)) {
+      result = TARGET;
+    } else if (!coversRole(REFERENCE)) {
+      result = REFERENCE;
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IMatch#isAMove()
+   * @generated NOT
+   */
+  public boolean isAMove() {
+    boolean result = false;
+    if (!isPartial() && getElementPresenceDifference() == null) {
+      IReferenceValuePresence<E> onTarget = getOwnershipDifference(Role.TARGET);
+      IReferenceValuePresence<E> onReference = getOwnershipDifference(
+          Role.REFERENCE);
+      result = onTarget != null || onReference != null;
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IPureMatch#isPartial()
+   * @generated NOT
+   */
+  public boolean isPartial() {
+    return getUncoveredRole() != null;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IPureMatch#isPartial(org.eclipse.emf.diffmerge.generic.api.Role, org.eclipse.emf.diffmerge.generic.api.Role)
+   * @generated NOT
+   */
+  public boolean isPartial(Role role1_p, Role role2_p) {
+    return !coversRole(role1_p) || !coversRole(role2_p);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IPureMatch#maps(java.lang.Object, java.lang.Object)
+   * @generated NOT
+   */
+  public boolean maps(E target_p, E reference_p) {
+    return get(TARGET) == target_p && get(REFERENCE) == reference_p;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IPureMatch#maps(java.lang.Object, java.lang.Object, java.lang.Object)
+   * @generated NOT
+   */
+  public boolean maps(E target_p, E reference_p, E ancestor_p) {
+    return maps(target_p, reference_p) && get(ANCESTOR) == ancestor_p;
+  }
+
+  /**
+   * Create and return a list for storing attribute value presences, and add it
+   * to the modifiable attribute value presence map
+   * @param attribute_p the non-null attribute
+   * @return a non-null, empty, modifiable map
+   * @generated NOT
+   */
+  protected abstract EList<IAttributeValuePresence<E>> newAttributeValuePresenceList(
+      A attribute_p);
+
+  /**
+   * Create and return a list for storing order differences, and add it
+   * to the modifiable order difference map
+   * @param reference_p the non-null reference
+   * @return a non-null, empty, modifiable map
+   * @generated NOT
+   */
+  protected abstract EList<IReferenceValuePresence<E>> newReferenceOrderDifferenceList(
+      R reference_p);
+
+  /**
+   * Create and return a map for: reference value -> difference, and add it
+   * to the modifiable reference map
+   * @param reference_p the non-null reference
+   * @return a non-null, empty, modifiable map
+   * @generated NOT
+   */
+  protected abstract EMap<E, IReferenceValuePresence<E>> newReferenceValueToPresenceMap(
+      R reference_p);
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.IPureMatch.Editable#set(org.eclipse.emf.diffmerge.generic.api.Role, java.lang.Object)
+   * @generated NOT
+   */
+  public void set(Role role_p, E element_p) {
+    switch (role_p) {
+    case TARGET:
+      setTarget(element_p);
+      break;
+    case REFERENCE:
+      setReference(element_p);
+      break;
+    default:
+      setAncestor(element_p);
+    }
+  }
+
+} //GMatchImpl
diff --git a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/diffdata/impl/EMergeableDifferenceImpl.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GMergeableDifferenceImpl.java
similarity index 62%
rename from plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/diffdata/impl/EMergeableDifferenceImpl.java
rename to plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GMergeableDifferenceImpl.java
index e81d8f5..42818a5 100644
--- a/plugins/org.eclipse.emf.diffmerge/src/org/eclipse/emf/diffmerge/diffdata/impl/EMergeableDifferenceImpl.java
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GMergeableDifferenceImpl.java
@@ -9,27 +9,29 @@
  * Contributors:
  *    Thales Global Services S.A.S. - initial API and implementation
  **********************************************************************/
-package org.eclipse.emf.diffmerge.diffdata.impl;
+package org.eclipse.emf.diffmerge.generic.gdiffdata.impl;
 
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.List;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.diffmerge.Messages;
-import org.eclipse.emf.diffmerge.api.Role;
-import org.eclipse.emf.diffmerge.api.diff.IDifference;
-import org.eclipse.emf.diffmerge.api.diff.IMergeableDifference;
-import org.eclipse.emf.diffmerge.diffdata.DiffdataPackage;
-import org.eclipse.emf.diffmerge.diffdata.EComparison;
-import org.eclipse.emf.diffmerge.diffdata.EMergeableDifference;
+import org.eclipse.emf.diffmerge.generic.Messages;
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.diff.IDifference;
+import org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GComparison;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMergeableDifference;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage;
+import org.eclipse.emf.diffmerge.structures.IEqualityBasedStructure;
 import org.eclipse.emf.diffmerge.structures.IEqualityTester;
 import org.eclipse.emf.diffmerge.structures.common.FArrayList;
 import org.eclipse.emf.diffmerge.structures.common.FHashSet;
+import org.eclipse.emf.diffmerge.structures.common.FLinkedList;
 import org.eclipse.emf.diffmerge.structures.endo.AbstractEndorelation;
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
 import org.eclipse.emf.ecore.util.EObjectResolvingEList;
@@ -42,33 +44,22 @@
  * The following features are implemented:
  * </p>
  * <ul>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EMergeableDifferenceImpl#getComparison <em>Comparison</em>}</li>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EMergeableDifferenceImpl#isAlignedWithAncestor <em>Aligned With Ancestor</em>}</li>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EMergeableDifferenceImpl#isConflicting <em>Conflicting</em>}</li>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EMergeableDifferenceImpl#isIgnored <em>Ignored</em>}</li>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EMergeableDifferenceImpl#getMergeDestination <em>Merge Destination</em>}</li>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EMergeableDifferenceImpl#getPossibleMergeDestinations <em>Possible Merge Destinations</em>}</li>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EMergeableDifferenceImpl#getExplicitDependenciesForTarget <em>Explicit Dependencies For Target</em>}</li>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EMergeableDifferenceImpl#getExplicitDependenciesForReference <em>Explicit Dependencies For Reference</em>}</li>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EMergeableDifferenceImpl#getImplicitDependenciesForTarget <em>Implicit Dependencies For Target</em>}</li>
- *   <li>{@link org.eclipse.emf.diffmerge.diffdata.impl.EMergeableDifferenceImpl#getImplicitDependenciesForReference <em>Implicit Dependencies For Reference</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl#isAlignedWithAncestor <em>Aligned With Ancestor</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl#isConflicting <em>Conflicting</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl#isIgnored <em>Ignored</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl#getMergeDestination <em>Merge Destination</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl#getPossibleMergeDestinations <em>Possible Merge Destinations</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl#getExplicitDependenciesForTarget <em>Explicit Dependencies For Target</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl#getExplicitDependenciesForReference <em>Explicit Dependencies For Reference</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl#getImplicitDependenciesForTarget <em>Implicit Dependencies For Target</em>}</li>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GMergeableDifferenceImpl#getImplicitDependenciesForReference <em>Implicit Dependencies For Reference</em>}</li>
  * </ul>
  *
  * @generated
  */
 @SuppressWarnings("boxing")
-public abstract class EMergeableDifferenceImpl extends EIdentifiedImpl
-    implements EMergeableDifference {
-  /**
-   * The cached value of the '{@link #getComparison() <em>Comparison</em>}' reference.
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @see #getComparison()
-   * @generated
-   * @ordered
-   */
-  protected EComparison comparison;
-
+public abstract class GMergeableDifferenceImpl<E, A, R> extends GIdentifiedImpl
+    implements GMergeableDifference<E, A, R> {
   /**
    * The default value of the '{@link #isAlignedWithAncestor() <em>Aligned With Ancestor</em>}' attribute.
    * <!-- begin-user-doc -->
@@ -167,7 +158,7 @@
    * @generated
    * @ordered
    */
-  protected EList<IMergeableDifference> explicitDependenciesForTarget;
+  protected EList<IMergeableDifference<E>> explicitDependenciesForTarget;
 
   /**
    * The cached value of the '{@link #getExplicitDependenciesForReference() <em>Explicit Dependencies For Reference</em>}' reference list.
@@ -177,7 +168,7 @@
    * @generated
    * @ordered
    */
-  protected EList<IMergeableDifference> explicitDependenciesForReference;
+  protected EList<IMergeableDifference<E>> explicitDependenciesForReference;
 
   /**
    * The cached value of the '{@link #getImplicitDependenciesForTarget() <em>Implicit Dependencies For Target</em>}' reference list.
@@ -187,7 +178,7 @@
    * @generated
    * @ordered
    */
-  protected EList<IMergeableDifference> implicitDependenciesForTarget;
+  protected EList<IMergeableDifference<E>> implicitDependenciesForTarget;
 
   /**
    * The cached value of the '{@link #getImplicitDependenciesForReference() <em>Implicit Dependencies For Reference</em>}' reference list.
@@ -197,38 +188,38 @@
    * @generated
    * @ordered
    */
-  protected EList<IMergeableDifference> implicitDependenciesForReference;
+  protected EList<IMergeableDifference<E>> implicitDependenciesForReference;
 
   /**
    * The set of all implicit dependencies on the TARGET side (initially null, assigned once)
    * @generated NOT
    */
-  private transient Collection<IMergeableDifference> _allImplicitDependenciesTarget;
+  private transient Collection<IMergeableDifference<E>> _allImplicitDependenciesTarget;
 
   /**
    * The set of all implicit dependencies on the REFERENCE side (initially null, assigned once)
    * @generated NOT
    */
-  private transient Collection<IMergeableDifference> _allImplicitDependenciesReference;
+  private transient Collection<IMergeableDifference<E>> _allImplicitDependenciesReference;
 
   /**
    * The set of all explicit dependencies on the TARGET side (initially null, assigned once)
    * @generated NOT
    */
-  private transient Collection<IMergeableDifference> _allExplicitDependenciesTarget;
+  private transient Collection<IMergeableDifference<E>> _allExplicitDependenciesTarget;
 
   /**
    * The set of all explicit dependencies on the REFERENCE side (initially null, assigned once)
    * @generated NOT
    */
-  private transient Collection<IMergeableDifference> _allExplicitDependenciesReference;
+  private transient Collection<IMergeableDifference<E>> _allExplicitDependenciesReference;
 
   /**
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @generated NOT
    */
-  protected EMergeableDifferenceImpl() {
+  protected GMergeableDifferenceImpl() {
     this(true);
   }
 
@@ -238,7 +229,7 @@
    * <!-- end-user-doc -->
    * @generated NOT
    */
-  protected EMergeableDifferenceImpl(boolean deferInit_p) {
+  protected GMergeableDifferenceImpl(boolean deferInit_p) {
     super();
     _allImplicitDependenciesTarget = null;
     _allImplicitDependenciesReference = null;
@@ -257,49 +248,7 @@
    */
   @Override
   protected EClass eStaticClass() {
-    return DiffdataPackage.Literals.EMERGEABLE_DIFFERENCE;
-  }
-
-  /**
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @generated
-   */
-  public EComparison getComparison() {
-    if (comparison != null && comparison.eIsProxy()) {
-      InternalEObject oldComparison = (InternalEObject) comparison;
-      comparison = (EComparison) eResolveProxy(oldComparison);
-      if (comparison != oldComparison) {
-        if (eNotificationRequired())
-          eNotify(new ENotificationImpl(this, Notification.RESOLVE,
-              DiffdataPackage.EMERGEABLE_DIFFERENCE__COMPARISON, oldComparison,
-              comparison));
-      }
-    }
-    return comparison;
-  }
-
-  /**
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @generated
-   */
-  public EComparison basicGetComparison() {
-    return comparison;
-  }
-
-  /**
-   * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-   * @generated
-   */
-  public void setComparison(EComparison newComparison) {
-    EComparison oldComparison = comparison;
-    comparison = newComparison;
-    if (eNotificationRequired())
-      eNotify(new ENotificationImpl(this, Notification.SET,
-          DiffdataPackage.EMERGEABLE_DIFFERENCE__COMPARISON, oldComparison,
-          comparison));
+    return GdiffdataPackage.Literals.GMERGEABLE_DIFFERENCE;
   }
 
   /**
@@ -321,7 +270,7 @@
     alignedWithAncestor = newAlignedWithAncestor;
     if (eNotificationRequired())
       eNotify(new ENotificationImpl(this, Notification.SET,
-          DiffdataPackage.EMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR,
+          GdiffdataPackage.GMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR,
           oldAlignedWithAncestor, alignedWithAncestor));
   }
 
@@ -344,7 +293,7 @@
     conflicting = newConflicting;
     if (eNotificationRequired())
       eNotify(new ENotificationImpl(this, Notification.SET,
-          DiffdataPackage.EMERGEABLE_DIFFERENCE__CONFLICTING, oldConflicting,
+          GdiffdataPackage.GMERGEABLE_DIFFERENCE__CONFLICTING, oldConflicting,
           conflicting));
   }
 
@@ -367,7 +316,8 @@
     ignored = newIgnored;
     if (eNotificationRequired())
       eNotify(new ENotificationImpl(this, Notification.SET,
-          DiffdataPackage.EMERGEABLE_DIFFERENCE__IGNORED, oldIgnored, ignored));
+          GdiffdataPackage.GMERGEABLE_DIFFERENCE__IGNORED, oldIgnored,
+          ignored));
   }
 
   /**
@@ -389,7 +339,7 @@
     mergeDestination = newMergeDestination;
     if (eNotificationRequired())
       eNotify(new ENotificationImpl(this, Notification.SET,
-          DiffdataPackage.EMERGEABLE_DIFFERENCE__MERGE_DESTINATION,
+          GdiffdataPackage.GMERGEABLE_DIFFERENCE__MERGE_DESTINATION,
           oldMergeDestination, mergeDestination));
   }
 
@@ -402,7 +352,7 @@
     if (possibleMergeDestinations == null) {
       possibleMergeDestinations = new EDataTypeUniqueEList<Role>(Role.class,
           this,
-          DiffdataPackage.EMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS);
+          GdiffdataPackage.GMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS);
     }
     return possibleMergeDestinations;
   }
@@ -412,11 +362,11 @@
    * <!-- end-user-doc -->
    * @generated
    */
-  public EList<IMergeableDifference> getExplicitDependenciesForTarget() {
+  public EList<IMergeableDifference<E>> getExplicitDependenciesForTarget() {
     if (explicitDependenciesForTarget == null) {
-      explicitDependenciesForTarget = new EObjectResolvingEList<IMergeableDifference>(
+      explicitDependenciesForTarget = new EObjectResolvingEList<IMergeableDifference<E>>(
           IMergeableDifference.class, this,
-          DiffdataPackage.EMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET);
+          GdiffdataPackage.GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET);
     }
     return explicitDependenciesForTarget;
   }
@@ -426,11 +376,11 @@
    * <!-- end-user-doc -->
    * @generated
    */
-  public EList<IMergeableDifference> getExplicitDependenciesForReference() {
+  public EList<IMergeableDifference<E>> getExplicitDependenciesForReference() {
     if (explicitDependenciesForReference == null) {
-      explicitDependenciesForReference = new EObjectResolvingEList<IMergeableDifference>(
+      explicitDependenciesForReference = new EObjectResolvingEList<IMergeableDifference<E>>(
           IMergeableDifference.class, this,
-          DiffdataPackage.EMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE);
+          GdiffdataPackage.GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE);
     }
     return explicitDependenciesForReference;
   }
@@ -440,11 +390,11 @@
    * <!-- end-user-doc -->
    * @generated
    */
-  public EList<IMergeableDifference> getImplicitDependenciesForTarget() {
+  public EList<IMergeableDifference<E>> getImplicitDependenciesForTarget() {
     if (implicitDependenciesForTarget == null) {
-      implicitDependenciesForTarget = new EObjectResolvingEList<IMergeableDifference>(
+      implicitDependenciesForTarget = new EObjectResolvingEList<IMergeableDifference<E>>(
           IMergeableDifference.class, this,
-          DiffdataPackage.EMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET);
+          GdiffdataPackage.GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET);
     }
     return implicitDependenciesForTarget;
   }
@@ -454,16 +404,22 @@
    * <!-- end-user-doc -->
    * @generated
    */
-  public EList<IMergeableDifference> getImplicitDependenciesForReference() {
+  public EList<IMergeableDifference<E>> getImplicitDependenciesForReference() {
     if (implicitDependenciesForReference == null) {
-      implicitDependenciesForReference = new EObjectResolvingEList<IMergeableDifference>(
+      implicitDependenciesForReference = new EObjectResolvingEList<IMergeableDifference<E>>(
           IMergeableDifference.class, this,
-          DiffdataPackage.EMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE);
+          GdiffdataPackage.GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE);
     }
     return implicitDependenciesForReference;
   }
 
   /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GComparisonElement#getComparison()
+   * @generated NOT
+   */
+  public abstract GComparison<E, A, R> getComparison();
+
+  /**
    * <!-- begin-user-doc -->
    * <!-- end-user-doc -->
    * @generated
@@ -471,27 +427,23 @@
   @Override
   public Object eGet(int featureID, boolean resolve, boolean coreType) {
     switch (featureID) {
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__COMPARISON:
-      if (resolve)
-        return getComparison();
-      return basicGetComparison();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR:
       return isAlignedWithAncestor();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__CONFLICTING:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__CONFLICTING:
       return isConflicting();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IGNORED:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IGNORED:
       return isIgnored();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__MERGE_DESTINATION:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__MERGE_DESTINATION:
       return getMergeDestination();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS:
       return getPossibleMergeDestinations();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET:
       return getExplicitDependenciesForTarget();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE:
       return getExplicitDependenciesForReference();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET:
       return getImplicitDependenciesForTarget();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE:
       return getImplicitDependenciesForReference();
     }
     return super.eGet(featureID, resolve, coreType);
@@ -506,45 +458,42 @@
   @Override
   public void eSet(int featureID, Object newValue) {
     switch (featureID) {
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__COMPARISON:
-      setComparison((EComparison) newValue);
-      return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR:
       setAlignedWithAncestor((Boolean) newValue);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__CONFLICTING:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__CONFLICTING:
       setConflicting((Boolean) newValue);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IGNORED:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IGNORED:
       setIgnored((Boolean) newValue);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__MERGE_DESTINATION:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__MERGE_DESTINATION:
       setMergeDestination((Role) newValue);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS:
       getPossibleMergeDestinations().clear();
       getPossibleMergeDestinations()
           .addAll((Collection<? extends Role>) newValue);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET:
       getExplicitDependenciesForTarget().clear();
       getExplicitDependenciesForTarget()
-          .addAll((Collection<? extends IMergeableDifference>) newValue);
+          .addAll((Collection<? extends IMergeableDifference<E>>) newValue);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE:
       getExplicitDependenciesForReference().clear();
       getExplicitDependenciesForReference()
-          .addAll((Collection<? extends IMergeableDifference>) newValue);
+          .addAll((Collection<? extends IMergeableDifference<E>>) newValue);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET:
       getImplicitDependenciesForTarget().clear();
       getImplicitDependenciesForTarget()
-          .addAll((Collection<? extends IMergeableDifference>) newValue);
+          .addAll((Collection<? extends IMergeableDifference<E>>) newValue);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE:
       getImplicitDependenciesForReference().clear();
       getImplicitDependenciesForReference()
-          .addAll((Collection<? extends IMergeableDifference>) newValue);
+          .addAll((Collection<? extends IMergeableDifference<E>>) newValue);
       return;
     }
     super.eSet(featureID, newValue);
@@ -558,34 +507,31 @@
   @Override
   public void eUnset(int featureID) {
     switch (featureID) {
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__COMPARISON:
-      setComparison((EComparison) null);
-      return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR:
       setAlignedWithAncestor(ALIGNED_WITH_ANCESTOR_EDEFAULT);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__CONFLICTING:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__CONFLICTING:
       setConflicting(CONFLICTING_EDEFAULT);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IGNORED:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IGNORED:
       setIgnored(IGNORED_EDEFAULT);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__MERGE_DESTINATION:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__MERGE_DESTINATION:
       setMergeDestination(MERGE_DESTINATION_EDEFAULT);
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS:
       getPossibleMergeDestinations().clear();
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET:
       getExplicitDependenciesForTarget().clear();
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE:
       getExplicitDependenciesForReference().clear();
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET:
       getImplicitDependenciesForTarget().clear();
       return;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE:
       getImplicitDependenciesForReference().clear();
       return;
     }
@@ -600,30 +546,28 @@
   @Override
   public boolean eIsSet(int featureID) {
     switch (featureID) {
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__COMPARISON:
-      return comparison != null;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__ALIGNED_WITH_ANCESTOR:
       return alignedWithAncestor != ALIGNED_WITH_ANCESTOR_EDEFAULT;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__CONFLICTING:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__CONFLICTING:
       return conflicting != CONFLICTING_EDEFAULT;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IGNORED:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IGNORED:
       return ignored != IGNORED_EDEFAULT;
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__MERGE_DESTINATION:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__MERGE_DESTINATION:
       return MERGE_DESTINATION_EDEFAULT == null ? mergeDestination != null
           : !MERGE_DESTINATION_EDEFAULT.equals(mergeDestination);
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__POSSIBLE_MERGE_DESTINATIONS:
       return possibleMergeDestinations != null
           && !possibleMergeDestinations.isEmpty();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_TARGET:
       return explicitDependenciesForTarget != null
           && !explicitDependenciesForTarget.isEmpty();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__EXPLICIT_DEPENDENCIES_FOR_REFERENCE:
       return explicitDependenciesForReference != null
           && !explicitDependenciesForReference.isEmpty();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_TARGET:
       return implicitDependenciesForTarget != null
           && !implicitDependenciesForTarget.isEmpty();
-    case DiffdataPackage.EMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE:
+    case GdiffdataPackage.GMERGEABLE_DIFFERENCE__IMPLICIT_DEPENDENCIES_FOR_REFERENCE:
       return implicitDependenciesForReference != null
           && !implicitDependenciesForReference.isEmpty();
     }
@@ -656,7 +600,7 @@
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IDifference#canMergeTo(org.eclipse.emf.diffmerge.api.Role)
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IDifference#canMergeTo(org.eclipse.emf.diffmerge.generic.api.Role)
    * @generated NOT
    */
   public boolean canMergeTo(Role destination_p) {
@@ -670,7 +614,7 @@
    * @param destination_p a non-null role which represents the destination of the merge
    * @generated NOT
    */
-  protected void checkMerge(IMergeableDifference difference_p,
+  protected void checkMerge(IMergeableDifference<E> difference_p,
       Role destination_p) {
     if (getMergeDestination() != destination_p && !canMergeTo(destination_p))
       throw new UnsupportedOperationException(
@@ -678,7 +622,7 @@
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IMergeableDifference.Editable#doMergeIn(org.eclipse.emf.diffmerge.api.Role)
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable#doMergeIn(org.eclipse.emf.diffmerge.generic.api.Role)
    * @generated NOT
    */
   public abstract void doMergeIn(Role destination_p);
@@ -690,58 +634,63 @@
    * @generated NOT
    */
   protected final void forbidMergeTo(Role destination_p) {
-    if (destination_p != null)
+    if (destination_p != null) {
       getPossibleMergeDestinations().remove(destination_p);
+    }
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IMergeableDifference#getDirectImpliesDependencies(org.eclipse.emf.diffmerge.api.Role)
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference#getDirectImpliesDependencies(org.eclipse.emf.diffmerge.generic.api.Role)
    * @generated NOT
    */
-  public final Collection<IMergeableDifference> getDirectImpliesDependencies(
+  public final Collection<IMergeableDifference<E>> getDirectImpliesDependencies(
       Role role_p) {
-    Collection<IMergeableDifference> result;
-    Collection<IMergeableDifference> obtained;
+    Collection<IMergeableDifference<E>> result;
+    Collection<IMergeableDifference<E>> obtained;
     switch (role_p) {
     case TARGET:
       obtained = getImplicitDependenciesForTarget(false);
-      if (obtained == null)
+      if (obtained == null) {
         result = Collections.emptyList();
-      else
+      } else {
         result = Collections.unmodifiableCollection(obtained);
+      }
       break;
     default:
       obtained = getImplicitDependenciesForReference(false);
-      if (obtained == null)
+      if (obtained == null) {
         result = Collections.emptyList();
-      else
+      } else {
         result = Collections.unmodifiableCollection(obtained);
+      }
     }
     return result;
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IMergeableDifference#getDirectRequiresDependencies(org.eclipse.emf.diffmerge.api.Role)
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference#getDirectRequiresDependencies(org.eclipse.emf.diffmerge.generic.api.Role)
    * @generated NOT
    */
-  public final Collection<IMergeableDifference> getDirectRequiresDependencies(
+  public final Collection<IMergeableDifference<E>> getDirectRequiresDependencies(
       Role role_p) {
-    Collection<IMergeableDifference> result;
-    Collection<IMergeableDifference> obtained;
+    Collection<IMergeableDifference<E>> result;
+    Collection<IMergeableDifference<E>> obtained;
     switch (role_p) {
     case TARGET:
       obtained = getExplicitDependenciesForTarget(false);
-      if (obtained == null)
+      if (obtained == null) {
         result = Collections.emptyList();
-      else
+      } else {
         result = Collections.unmodifiableCollection(obtained);
+      }
       break;
     default:
       obtained = getExplicitDependenciesForReference(false);
-      if (obtained == null)
+      if (obtained == null) {
         result = Collections.emptyList();
-      else
+      } else {
         result = Collections.unmodifiableCollection(obtained);
+      }
     }
     return result;
   }
@@ -751,7 +700,7 @@
    * @param create_p whether the result must be computed if not available yet, otherwise null may be returned
    * @generated NOT
    */
-  public EList<IMergeableDifference> getExplicitDependenciesForReference(
+  public EList<IMergeableDifference<E>> getExplicitDependenciesForReference(
       boolean create_p) {
     return create_p ? getExplicitDependenciesForReference()
         : explicitDependenciesForReference;
@@ -762,7 +711,7 @@
    * @param create_p whether the result must be computed if not available yet, otherwise null may be returned
    * @generated NOT
    */
-  public EList<IMergeableDifference> getImplicitDependenciesForReference(
+  public EList<IMergeableDifference<E>> getImplicitDependenciesForReference(
       boolean create_p) {
     return create_p ? getImplicitDependenciesForReference()
         : implicitDependenciesForReference;
@@ -773,7 +722,7 @@
    * @param create_p whether the result must be computed if not available yet, otherwise null may be returned
    * @generated NOT
    */
-  public EList<IMergeableDifference> getExplicitDependenciesForTarget(
+  public EList<IMergeableDifference<E>> getExplicitDependenciesForTarget(
       boolean create_p) {
     return create_p ? getExplicitDependenciesForTarget()
         : explicitDependenciesForTarget;
@@ -784,60 +733,62 @@
    * @param create_p whether the result must be computed if not available yet, otherwise null may be returned
    * @generated NOT
    */
-  public EList<IMergeableDifference> getImplicitDependenciesForTarget(
+  public EList<IMergeableDifference<E>> getImplicitDependenciesForTarget(
       boolean create_p) {
     return create_p ? getImplicitDependenciesForTarget()
         : implicitDependenciesForTarget;
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IMergeableDifference#getImpliesDependencies(org.eclipse.emf.diffmerge.api.Role)
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference#getImpliesDependencies(org.eclipse.emf.diffmerge.generic.api.Role)
    * @generated NOT
    */
-  public final Collection<IMergeableDifference> getImpliesDependencies(
+  public final Collection<IMergeableDifference<E>> getImpliesDependencies(
       Role role_p) {
-    Collection<IMergeableDifference> result = (role_p == Role.TARGET)
+    Collection<IMergeableDifference<E>> result = (role_p == Role.TARGET)
         ? _allImplicitDependenciesTarget
         : _allImplicitDependenciesReference;
     if (result == null) {
-      Collection<IMergeableDifference> required = getRequiresDependencies(
+      Collection<IMergeableDifference<E>> required = getRequiresDependencies(
           role_p);
-      Collection<IMergeableDifference> allRequired = new FArrayList<IMergeableDifference>(
+      Collection<IMergeableDifference<E>> allRequired = new FArrayList<IMergeableDifference<E>>(
           required.size() + 1, null);
       allRequired.add(this);
       allRequired.addAll(required);
-      result = new DifferenceDependencyRelation(role_p, false)
+      result = new DifferenceDependencyRelation<E>(role_p, false)
           .getTransitiveClosure(allRequired);
-      if (role_p == Role.TARGET)
+      if (role_p == Role.TARGET) {
         _allImplicitDependenciesTarget = result;
-      else
+      } else {
         _allImplicitDependenciesReference = result;
+      }
     }
     return result;
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IMergeableDifference#getRequiresDependencies(org.eclipse.emf.diffmerge.api.Role)
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference#getRequiresDependencies(org.eclipse.emf.diffmerge.generic.api.Role)
    * @generated NOT
    */
-  public final Collection<IMergeableDifference> getRequiresDependencies(
+  public final Collection<IMergeableDifference<E>> getRequiresDependencies(
       Role role_p) {
-    Collection<IMergeableDifference> result = (role_p == Role.TARGET)
+    Collection<IMergeableDifference<E>> result = (role_p == Role.TARGET)
         ? _allExplicitDependenciesTarget
         : _allExplicitDependenciesReference;
     if (result == null) {
-      result = new DifferenceDependencyRelation(role_p, true)
-          .getTransitiveClosure(this);
-      if (role_p == Role.TARGET)
+      result = reduceByImplies(new DifferenceDependencyRelation<E>(role_p, true)
+          .getTransitiveClosure(this), role_p);
+      if (role_p == Role.TARGET) {
         _allExplicitDependenciesTarget = result;
-      else
+      } else {
         _allExplicitDependenciesReference = result;
+      }
     }
     return result;
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IDifference#isMerged()
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IDifference#isMerged()
    * @generated NOT
    */
   public final boolean isMerged() {
@@ -845,36 +796,38 @@
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IMergeableDifference#mergeTo(org.eclipse.emf.diffmerge.api.Role)
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference#mergeTo(org.eclipse.emf.diffmerge.generic.api.Role)
    * @generated NOT
    */
-  public Collection<IDifference> mergeTo(Role destination_p) {
+  public Collection<IDifference<E>> mergeTo(Role destination_p) {
     // Checking ability to merge
     checkMerge(this, destination_p);
-    if (isMerged())
+    if (isMerged()) {
       return Collections.emptyList();
-    Collection<IMergeableDifference> allRequired = getRequiresDependencies(
+    }
+    Collection<IMergeableDifference<E>> allRequired = getRequiresDependencies(
         destination_p);
-    for (IMergeableDifference required : allRequired)
+    for (IMergeableDifference<E> required : allRequired) {
       checkMerge(required, destination_p);
+    }
     // Core behavior
     markAsMergedIn(destination_p);
-    Collection<IDifference> result = new HashSet<IDifference>();
-    for (IMergeableDifference required : allRequired) {
+    Collection<IDifference<E>> result = new HashSet<IDifference<E>>();
+    for (IMergeableDifference<E> required : allRequired) {
       if (!required.isMerged()) {
-        ((IMergeableDifference.Editable) required)
+        ((IMergeableDifference.Editable<E>) required)
             .markAsMergedIn(destination_p);
-        ((IMergeableDifference.Editable) required).doMergeIn(destination_p);
+        ((IMergeableDifference.Editable<E>) required).doMergeIn(destination_p);
         result.add(required);
       }
     }
     doMergeIn(destination_p);
     result.add(this);
     // Mark implicit dependencies as merged
-    for (IMergeableDifference implicit : getImpliesDependencies(
+    for (IMergeableDifference<E> implicit : getImpliesDependencies(
         destination_p)) {
       if (!implicit.isMerged()) {
-        ((IMergeableDifference.Editable) implicit)
+        ((IMergeableDifference.Editable<E>) implicit)
             .markAsMergedIn(destination_p);
         result.add(implicit);
       }
@@ -883,7 +836,7 @@
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IDifference.Editable#markAsConflicting()
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IDifference.Editable#markAsConflicting()
    * @generated NOT
    */
   public void markAsConflicting() {
@@ -892,7 +845,7 @@
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IDifference.Editable#markAsDifferentFromAncestor()
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IDifference.Editable#markAsDifferentFromAncestor()
    * @generated NOT
    */
   public void markAsDifferentFromAncestor() {
@@ -900,7 +853,7 @@
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IMergeableDifference.Editable#markAsMergedIn(org.eclipse.emf.diffmerge.api.Role)
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable#markAsMergedIn(org.eclipse.emf.diffmerge.generic.api.Role)
    * @generated NOT
    */
   public void markAsMergedIn(Role destination_p) {
@@ -911,12 +864,12 @@
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IMergeableDifference.Editable#markImplies(org.eclipse.emf.diffmerge.api.diff.IMergeableDifference, org.eclipse.emf.diffmerge.api.Role)
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable#markImplies(org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference, org.eclipse.emf.diffmerge.generic.api.Role)
    * @generated NOT
    */
-  public final void markImplies(IMergeableDifference difference_p,
+  public final void markImplies(IMergeableDifference<E> difference_p,
       Role role_p) {
-    Collection<IMergeableDifference> toChange;
+    Collection<IMergeableDifference<E>> toChange;
     switch (role_p) {
     case TARGET:
       toChange = getImplicitDependenciesForTarget(true);
@@ -924,17 +877,18 @@
     default:
       toChange = getImplicitDependenciesForReference(true);
     }
-    if (!toChange.contains(difference_p))
+    if (!toChange.contains(difference_p)) {
       toChange.add(difference_p);
+    }
   }
 
   /**
-   * @see org.eclipse.emf.diffmerge.api.diff.IMergeableDifference.Editable#markRequires(org.eclipse.emf.diffmerge.api.diff.IMergeableDifference, org.eclipse.emf.diffmerge.api.Role)
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference.Editable#markRequires(org.eclipse.emf.diffmerge.generic.api.diff.IMergeableDifference, org.eclipse.emf.diffmerge.generic.api.Role)
    * @generated NOT
    */
-  public final void markRequires(IMergeableDifference difference_p,
+  public final void markRequires(IMergeableDifference<E> difference_p,
       Role role_p) {
-    Collection<IMergeableDifference> toChange;
+    Collection<IMergeableDifference<E>> toChange;
     switch (role_p) {
     case TARGET:
       toChange = getExplicitDependenciesForTarget(true);
@@ -942,8 +896,30 @@
     default:
       toChange = getExplicitDependenciesForReference(true);
     }
-    if (!toChange.contains(difference_p))
+    if (!toChange.contains(difference_p)) {
       toChange.add(difference_p);
+    }
+  }
+
+  /**
+   * Reduce the content of the given list based on the implies relation on the
+   * given side
+   * @param originalCollection_p a non-null, potentially empty list
+   * @param role_p TARGET or REFERENCE
+   * @return a non-null, potentially empty list
+   * @generated NOT
+   */
+  protected List<IMergeableDifference<E>> reduceByImplies(
+      Collection<IMergeableDifference<E>> originalCollection_p, Role role_p) {
+    IEqualityTester tester = (originalCollection_p instanceof IEqualityBasedStructure)
+        ? ((IEqualityBasedStructure) originalCollection_p).getEqualityTester()
+        : null;
+    List<IMergeableDifference<E>> result = new FLinkedList<IMergeableDifference<E>>(
+        originalCollection_p, tester);
+    for (IMergeableDifference<E> difference : originalCollection_p) {
+      result.removeAll(difference.getDirectImpliesDependencies(role_p));
+    }
+    return result;
   }
 
   /**
@@ -952,8 +928,8 @@
    * This class can be used to compute the transitive closure of inter-difference dependencies.
    * @generated NOT
    */
-  protected static class DifferenceDependencyRelation
-      extends AbstractEndorelation<IMergeableDifference> {
+  protected static class DifferenceDependencyRelation<E>
+      extends AbstractEndorelation<IMergeableDifference<E>> {
 
     /** The non-null role for dependency computation */
     private final Role _role;
@@ -975,14 +951,14 @@
     /**
      * @see org.eclipse.emf.diffmerge.structures.binary.IBinaryRelation#get(java.lang.Object)
      */
-    public Collection<IMergeableDifference> get(
-        IMergeableDifference element_p) {
-      Collection<IMergeableDifference> result;
+    public Collection<IMergeableDifference<E>> get(
+        IMergeableDifference<E> element_p) {
+      Collection<IMergeableDifference<E>> result;
       if (_isExplicit) {
-        result = new FHashSet<IMergeableDifference>(
+        result = new FHashSet<IMergeableDifference<E>>(
             element_p.getDirectRequiresDependencies(_role),
             IEqualityTester.BY_REFERENCE);
-        for (IMergeableDifference implicit : element_p
+        for (IMergeableDifference<E> implicit : element_p
             .getDirectImpliesDependencies(_role)) {
           result.addAll(implicit.getDirectRequiresDependencies(_role));
         }
@@ -993,4 +969,4 @@
     }
   }
 
-} //EMergeableDifferenceImpl
+} //GMergeableDifferenceImpl
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GReferenceValuePresenceImpl.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GReferenceValuePresenceImpl.java
new file mode 100644
index 0000000..db23f96
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GReferenceValuePresenceImpl.java
@@ -0,0 +1,504 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata.impl;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.diffmerge.generic.api.IComparison;
+import org.eclipse.emf.diffmerge.generic.api.IDiffPolicy;
+import org.eclipse.emf.diffmerge.generic.api.IMatch;
+import org.eclipse.emf.diffmerge.generic.api.IMergePolicy;
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IDataScope;
+import org.eclipse.emf.diffmerge.generic.api.scopes.IEditableTreeDataScope;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GReferenceValuePresence;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage;
+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>EReference Value Presence</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GReferenceValuePresenceImpl#getValueMatch <em>Value Match</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public abstract class GReferenceValuePresenceImpl<E, A, R> extends
+    GValuePresenceImpl<E, A, R> implements GReferenceValuePresence<E, A, R> {
+  /**
+   * The cached value of the '{@link #getValueMatch() <em>Value Match</em>}' reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getValueMatch()
+   * @generated
+   * @ordered
+   */
+  protected GMatch<E, A, R> valueMatch;
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected GReferenceValuePresenceImpl() {
+    super();
+  }
+
+  /**
+   * Constructor
+   * @param elementMatch_p the non-null match for the element holding the value
+   * @param reference_p the non-null reference holding the value
+   * @param value_p the value element, which is non-null unless valueMatch_p is not null
+   * @param valueMatch_p the optional match corresponding to the value held
+   * @param presenceRole_p the role in which the value is held: TARGET or REFERENCE
+   * @param isOrder_p whether the value presence is solely due to ordering
+   * @generated NOT
+   */
+  public GReferenceValuePresenceImpl(GMatch<E, A, R> elementMatch_p,
+      R reference_p, E value_p, GMatch<E, A, R> valueMatch_p,
+      Role presenceRole_p, boolean isOrder_p) {
+    super(elementMatch_p, presenceRole_p, isOrder_p);
+    assert valueMatch_p != null || value_p != null;
+    setValueMatch(valueMatch_p);
+    setValue((value_p != null) ? value_p : valueMatch_p.get(presenceRole_p));
+    assert getValue() != null;
+    setReference(reference_p);
+    ((IMatch.Editable<E>) elementMatch).addRelatedDifference(this);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return GdiffdataPackage.Literals.GREFERENCE_VALUE_PRESENCE;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  public GMatch<E, A, R> getValueMatch() {
+    if (valueMatch != null && valueMatch.eIsProxy()) {
+      InternalEObject oldValueMatch = (InternalEObject) valueMatch;
+      valueMatch = (GMatch<E, A, R>) eResolveProxy(oldValueMatch);
+      if (valueMatch != oldValueMatch) {
+        if (eNotificationRequired())
+          eNotify(new ENotificationImpl(this, Notification.RESOLVE,
+              GdiffdataPackage.GREFERENCE_VALUE_PRESENCE__VALUE_MATCH,
+              oldValueMatch, valueMatch));
+      }
+    }
+    return valueMatch;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public GMatch<E, A, R> basicGetValueMatch() {
+    return valueMatch;
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void setValueMatch(GMatch<E, A, R> newValueMatch) {
+    GMatch<E, A, R> oldValueMatch = valueMatch;
+    valueMatch = newValueMatch;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET,
+          GdiffdataPackage.GREFERENCE_VALUE_PRESENCE__VALUE_MATCH,
+          oldValueMatch, valueMatch));
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#getFeature()
+   * @generated NOT
+   */
+  @Override
+  public abstract R getFeature();
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated NOT
+   */
+  public abstract void setReference(R reference);
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.GReferenceValuePresence#setValue(java.lang.Object)
+   * @generated NOT
+   */
+  public abstract void setValue(E value);
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType) {
+    switch (featureID) {
+    case GdiffdataPackage.GREFERENCE_VALUE_PRESENCE__VALUE_MATCH:
+      if (resolve)
+        return getValueMatch();
+      return basicGetValueMatch();
+    }
+    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 GdiffdataPackage.GREFERENCE_VALUE_PRESENCE__VALUE_MATCH:
+      setValueMatch((GMatch<E, A, R>) newValue);
+      return;
+    }
+    super.eSet(featureID, newValue);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID) {
+    switch (featureID) {
+    case GdiffdataPackage.GREFERENCE_VALUE_PRESENCE__VALUE_MATCH:
+      setValueMatch((GMatch<E, A, R>) null);
+      return;
+    }
+    super.eUnset(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID) {
+    switch (featureID) {
+    case GdiffdataPackage.GREFERENCE_VALUE_PRESENCE__VALUE_MATCH:
+      return valueMatch != null;
+    }
+    return super.eIsSet(featureID);
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence#getOpposite()
+   * @generated NOT
+   */
+  public IReferenceValuePresence<E> getOpposite() {
+    IReferenceValuePresence<E> result = null;
+    Object opposite = getPresenceScope().mGetOppositeReference(getFeature());
+    if (opposite != null) {
+      IMatch<E> valueMatch = getValueMatch();
+      if (valueMatch != null) {
+        result = valueMatch.getReferenceValueDifference(opposite,
+            getElementMatch().get(getPresenceRole()));
+      }
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#getSymmetrical()
+   * @generated NOT
+   */
+  @Override
+  public IReferenceValuePresence<E> getSymmetrical() {
+    IReferenceValuePresence<E> result = null;
+    if (!isManyFeature()) {
+      Collection<IReferenceValuePresence<E>> candidates = getElementMatch()
+          .getReferenceDifferences(getFeature());
+      assert candidates.size() <= 2; // Because !isMany()
+      for (IReferenceValuePresence<E> candidate : candidates) {
+        if (candidate.getPresenceRole() == getAbsenceRole()) {
+          result = candidate;
+          break;
+        }
+      }
+    } else if (isOrder()) {
+      result = getElementMatch().getReferenceOrderDifference(getFeature(),
+          getAbsenceRole());
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence#getSymmetricalOwnership()
+   * @generated NOT
+   */
+  public IReferenceValuePresence<E> getSymmetricalOwnership() {
+    IReferenceValuePresence<E> result = null;
+    IMatch<E> valueMatch = getValueMatch();
+    if (valueMatch != null) {
+      result = valueMatch.getOwnershipDifference(getAbsenceRole());
+    }
+    return result;
+  }
+
+  /**
+   * Return whether this difference has an opposite with stronger constraints
+   * @generated NOT
+   */
+  protected boolean hasStrongerOpposite() {
+    boolean result = false;
+    if (isManyFeature()) {
+      IDataScope<E> presenceScope = getPresenceScope();
+      Object opposite = presenceScope.mGetOppositeReference(getFeature());
+      result = opposite != null && !presenceScope.mIsManyReference(opposite);
+    }
+    return result;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence#isContainment()
+   * @generated NOT
+   */
+  public boolean isContainment() {
+    return getPresenceScope().mIsContainmentReference(getFeature());
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#isManyFeature()
+   * @generated NOT
+   */
+  @Override
+  public boolean isManyFeature() {
+    return getPresenceScope().mIsManyReference(getFeature());
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence#isOppositeOf(org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence)
+   * @generated NOT
+   */
+  public boolean isOppositeOf(IReferenceValuePresence<E> peer_p) {
+    return getPresenceRole() == peer_p.getPresenceRole()
+        && getPresenceScope().mGetOppositeReference(getFeature()) == peer_p
+            .getFeature()
+        && getElementMatch() == peer_p.getValueMatch()
+        && getValueMatch() == peer_p.getElementMatch();
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence#isChangeableFeature()
+   * @generated NOT
+   */
+  public boolean isChangeableFeature() {
+    return getPresenceScope().mIsChangeableReference(getFeature());
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence#isOutOfScope()
+   * @generated NOT
+   */
+  public boolean isOutOfScope() {
+    return getValueMatch() == null;
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence#isOwnership()
+   * @generated NOT
+   */
+  public boolean isOwnership() {
+    return !isOrder() && isContainment();
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence#isSymmetricalOwnershipTo(org.eclipse.emf.diffmerge.generic.api.diff.IReferenceValuePresence)
+   * @generated NOT
+   */
+  public boolean isSymmetricalOwnershipTo(IReferenceValuePresence<E> peer_p) {
+    return getAbsenceRole() == peer_p.getPresenceRole() && isOwnership()
+        && peer_p.isOwnership() && getValueMatch() != null
+        && getValueMatch() == peer_p.getValueMatch();
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.api.diff.IElementRelativeDifference#isUnrelatedToContainmentTree()
+   * @generated NOT
+   */
+  public boolean isUnrelatedToContainmentTree() {
+    return !isOwnership();
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#mergeOrder()
+   * @generated NOT
+   */
+  @Override
+  protected void mergeOrder() {
+    E sourceHolder = getHolder();
+    E destinationHolder = getMatchOfHolder();
+    Object reference = getFeature();
+    assert sourceHolder != null && destinationHolder != null; // Otherwise order change would not have been detected
+    assert getFeature() != null; // Order merge does not cover root containment at this time
+    IEditableTreeDataScope<E> absenceScope = getAbsenceScope();
+    IEditableTreeDataScope<E> presenceScope = getPresenceScope();
+    IMergePolicy<E> mergePolicy = getComparison().getLastMergePolicy();
+    Role destination = getAbsenceRole();
+    IMatch<E> holderMatch = getElementMatch();
+    IComparison<E> owningComparison = getComparison();
+    List<E> sourceValues = presenceScope.getReferenceValues(sourceHolder,
+        reference);
+    for (int i = sourceValues.size() - 1; i >= 0; i--) {
+      E sourceValue = sourceValues.get(i);
+      IMatch<E> valueMatch = owningComparison.getMapping()
+          .getMatchFor(sourceValue, destination.opposite());
+      boolean coverValue = valueMatch != null
+          || getFeature() != null && getComparison().getLastDiffPolicy()
+              .coverOutOfScopeValue(sourceValue, getFeature(), presenceScope);
+      if (coverValue) {
+        E destinationValue = valueMatch != null ? valueMatch.get(destination)
+            : sourceValue;
+        if (destinationValue != null) {
+          int index = mergePolicy.getDesiredValuePosition(owningComparison,
+              destination, holderMatch, reference, sourceValue);
+          if (index >= 0) {
+            List<E> updatedDestinationValues = absenceScope
+                .getReferenceValues(destinationHolder, reference);
+            int oldIndex = updatedDestinationValues.indexOf(destinationValue);
+            absenceScope.moveReferenceValue(destinationHolder, reference, index,
+                oldIndex);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#mergeValueAddition()
+   * @generated NOT
+   */
+  @Override
+  protected void mergeValueAddition() {
+    IEditableTreeDataScope<E> absenceScope = getAbsenceScope();
+    IEditableTreeDataScope<E> presenceScope = getPresenceScope();
+    E destinationHolder = getMatchOfHolder();
+    IMatch<E> valueMatch = getValueMatch();
+    E destinationValue;
+    boolean cloned;
+    if (valueMatch == null) {
+      // Out of scope
+      destinationValue = getValue(); // Keep as-is
+      cloned = false;
+    } else if (valueMatch.isPartial()) {
+      // Within scope, value not present in absence scope
+      destinationValue = getComparison().getMapping().completeMatch(valueMatch);
+      cloned = true;
+    } else {
+      // Within scope, value present in absence scope
+      destinationValue = valueMatch.get(getAbsenceRole());
+      cloned = false;
+    }
+    // Assertions are assumed to be enforced by diff dependency handling
+    assert destinationHolder != null && destinationValue != null;
+    boolean actuallyAdded = absenceScope.addReferenceValue(destinationHolder,
+        getFeature(), destinationValue);
+    // Order handling
+    IDiffPolicy<E> diffPolicy = getComparison().getLastDiffPolicy();
+    IMergePolicy<E> mergePolicy = getComparison().getLastMergePolicy();
+    if (diffPolicy != null && actuallyAdded
+        && diffPolicy.considerOrderedReference(getFeature(), absenceScope)) {
+      // Move added value if required
+      int index = mergePolicy.getDesiredValuePosition(getComparison(),
+          getAbsenceRole(), getElementMatch(), getFeature(), getValue());
+      if (index >= 0) {
+        absenceScope.moveReferenceValue(destinationHolder, getFeature(), index,
+            -1);
+      }
+    }
+    // ID enforcement
+    if (cloned && actuallyAdded) {
+      mergePolicy.setID(getValue(), presenceScope, destinationValue,
+          absenceScope);
+    }
+  }
+
+  /**
+   * @see org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#mergeValueRemoval()
+   * @generated NOT
+   */
+  @Override
+  protected final void mergeValueRemoval() {
+    if (isOutOfScope()) {
+      // Out of scope
+      getPresenceScope().removeReferenceValue(getHolder(), getFeature(),
+          getValue());
+    } else {
+      // Within scope
+      mergeValueRemovalWithinScope();
+    }
+  }
+
+  /**
+   * Remove the in-presence-scope value from the presence scope.
+   * Precondition: !isOutOfScope()
+   * @generated NOT
+   */
+  protected void mergeValueRemovalWithinScope() {
+    IEditableTreeDataScope<E> presenceScope = getPresenceScope();
+    if (getSymmetrical() == null
+        && !(hasStrongerOpposite() && !getValueMatch().isPartial())) {
+      E valueElement = getValue();
+      if (isOwnership()) {
+        // Value must be removed from its ownership so it is an element removal: disconnect element
+        getElementMatch().getMapping().disconnect(getPresenceRole(),
+            valueElement);
+      }
+      if (getFeature() != null) {
+        presenceScope.removeReferenceValue(getHolder(), getFeature(),
+            valueElement);
+      } else {
+        presenceScope.remove(valueElement);
+      }
+      if (isOwnership() && !getComparison().getLastMergePolicy()
+          .bindPresenceToOwnership(presenceScope)) {
+        // Re-integrate direct children in scope
+        for (E child : presenceScope.getContents(valueElement)) {
+          presenceScope.add(child);
+        }
+      }
+    }
+    // Otherwise, we know this difference will be merged implicitly because of dependencies
+    // since a required difference implies this difference
+  }
+
+} //GReferenceValuePresenceImpl
diff --git a/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GValuePresenceImpl.java b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GValuePresenceImpl.java
new file mode 100644
index 0000000..ba4e74f
--- /dev/null
+++ b/plugins/org.eclipse.emf.diffmerge.generic/src/org/eclipse/emf/diffmerge/generic/gdiffdata/impl/GValuePresenceImpl.java
@@ -0,0 +1,282 @@
+/*********************************************************************
+ * Copyright (c) 2010-2019 Thales Global Services S.A.S.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Thales Global Services S.A.S. - initial API and implementation
+ **********************************************************************/
+package org.eclipse.emf.diffmerge.generic.gdiffdata.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.diffmerge.generic.api.Role;
+import org.eclipse.emf.diffmerge.generic.api.diff.IValuePresence;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GMatch;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GValuePresence;
+import org.eclipse.emf.diffmerge.generic.gdiffdata.GdiffdataPackage;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>EValue Presence</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.emf.diffmerge.generic.gdiffdata.impl.GValuePresenceImpl#isOrder <em>O