## Uses of Interface
org.eclipse.emf.compare.Diff

Packages that use Diff
org.eclipse.emf.compare
org.eclipse.emf.compare.command.impl
org.eclipse.emf.compare.conflict
org.eclipse.emf.compare.domain
org.eclipse.emf.compare.domain.impl
org.eclipse.emf.compare.equi
org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer
org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.text
org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.tree.provider
org.eclipse.emf.compare.ide.ui.internal.logical
org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer
org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions
org.eclipse.emf.compare.impl
org.eclipse.emf.compare.internal.conflict
org.eclipse.emf.compare.internal.domain
org.eclipse.emf.compare.internal.merge
org.eclipse.emf.compare.internal.postprocessor.factories
org.eclipse.emf.compare.internal.spec
org.eclipse.emf.compare.internal.utils
org.eclipse.emf.compare.merge
org.eclipse.emf.compare.provider.spec
org.eclipse.emf.compare.rcp.ui.internal.contentmergeviewer
org.eclipse.emf.compare.rcp.ui.internal.contentmergeviewer.accessor.impl
org.eclipse.emf.compare.rcp.ui.internal.mergeviewer
org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.impl
org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.item.impl
org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl
org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.nodes
org.eclipse.emf.compare.rcp.ui.internal.util
org.eclipse.emf.compare.rcp.ui.mergeviewer
org.eclipse.emf.compare.rcp.ui.mergeviewer.item
org.eclipse.emf.compare.req
org.eclipse.emf.compare.util
org.eclipse.emf.compare.utils

### Uses of Diff in org.eclipse.emf.compare

Subinterfaces of Diff in org.eclipse.emf.compare
`interface` `AttributeChange` A representation of the model object 'Attribute Change'
`interface` `FeatureMapChange` A representation of the model object 'Feature Map Change'
`interface` `ReferenceChange` A representation of the model object 'Reference Change'
`interface` `ResourceAttachmentChange` A representation of the model object 'Resource Attachment Change'
`interface` `ResourceLocationChange` A representation of the model object 'Resource Location Change'

Methods in org.eclipse.emf.compare that return Diff
`Diff` CompareFactory.`createDiff()` Returns a new object of class 'Diff'
`Diff` Diff.`getPrimeRefining()` Returns the value of the 'Prime Refining' reference

Methods in org.eclipse.emf.compare that return types with arguments of type Diff
`Iterable<Diff>` Match.`getAllDifferences()` Finds and returns all differences contained in this Match and its children, recursively
`EList<Diff>` Match.`getDifferences()` Returns the value of the 'Differences' containment reference list.
`EList<Diff>` Equivalence.`getDifferences()` Returns the value of the 'Differences' reference list.
`EList<Diff>` Conflict.`getDifferences()` Returns the value of the 'Differences' reference list.
`EList<Diff>` Comparison.`getDifferences()` Returns all differences contained by this Comparison and its children.
`EList<Diff>` Comparison.`getDifferences(EObject element)` Returns all differences that reference the given EObject (for instance, all ReferenceChanges that reference the given EObject through the "value" EReference).
`EList<Diff>` Diff.`getImpliedBy()` Returns the value of the 'Implied By' reference list.
`EList<Diff>` Diff.`getImplies()` Returns the value of the 'Implies' reference list.
`EList<Diff>` Conflict.`getLeftDifferences()` This can be used to retrieve the list of differences that were made in the left element
`EList<Diff>` Diff.`getRefinedBy()` Returns the value of the 'Refined By' reference list.
`EList<Diff>` Diff.`getRefines()` Returns the value of the 'Refines' reference list.
`EList<Diff>` Diff.`getRequiredBy()` Returns the value of the 'Required By' reference list.
`EList<Diff>` Diff.`getRequires()` Returns the value of the 'Requires' reference list.
`EList<Diff>` Conflict.`getRightDifferences()` This can be used to retrieve the list of differences that were made in the right element

### Uses of Diff in org.eclipse.emf.compare.command.impl

Fields in org.eclipse.emf.compare.command.impl with type parameters of type Diff
`protected List<? extends Diff>` AbstractCopyCommand.`differences` The list of differences we are to merge.

Methods in org.eclipse.emf.compare.command.impl that return types with arguments of type Diff
`com.google.common.collect.Multimap<DifferenceState,Diff>` AbstractCopyCommand.`getChangedDiffs()` Returns the state changes to any diffs that this command produced.
`static com.google.common.collect.Multimap<DifferenceState,Diff>` AbstractCopyCommand.`getChangedDiffs(ChangeDescription changeDescription, Collection<? extends Diff> relevantDiffs)` Returns the state changes to any relevant diffs modified in the given change description.

Method parameters in org.eclipse.emf.compare.command.impl with type arguments of type Diff
`static com.google.common.collect.Multimap<DifferenceState,Diff>` AbstractCopyCommand.`getChangedDiffs(ChangeDescription changeDescription, Collection<? extends Diff> relevantDiffs)` Returns the state changes to any relevant diffs modified in the given change description.

Constructor parameters in org.eclipse.emf.compare.command.impl with type arguments of type Diff
Constructor and Description
`AbstractCopyCommand(ChangeRecorder changeRecorder, Collection<Notifier> notifiers, List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry)` Constructs an instance of this command given the list of differences that it needs to merge.
`CopyCommand(ChangeRecorder changeRecorder, Collection<Notifier> notifiers, List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry)` Deprecated. Constructs an instance of this command given the list of differences that it needs to merge.
`MergeCommand(ChangeRecorder changeRecorder, Collection<Notifier> notifiers, List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry, IMergeRunnable runnable)` Creates a new instance.

### Uses of Diff in org.eclipse.emf.compare.conflict

Methods in org.eclipse.emf.compare.conflict with parameters of type Diff
`protected void` DefaultConflictDetector.`checkConflict(Comparison comparison, Diff diff, Iterable<Diff> candidates)` This will be called once for each difference in the comparison model.
`protected void` DefaultConflictDetector.`checkFeatureAddConflict(Comparison comparison, Diff diff, Iterable<Diff> candidates)` This will be called from `DefaultConflictDetector.checkConflict(Comparison, Diff, Iterable)` in order to detect conflicts on a Diff that is of type "ADD" and which is not a containment reference change.
`protected void` DefaultConflictDetector.`checkFeatureChangeConflict(Comparison comparison, Diff diff, Iterable<Diff> candidates)` This will be called from `DefaultConflictDetector.checkConflict(Comparison, Diff, Iterable)` in order to detect conflicts on a Diff that is of type "CHANGE".
`protected void` DefaultConflictDetector.`checkFeatureDeleteConflict(Comparison comparison, Diff diff, Iterable<Diff> candidates)` This will be called from `DefaultConflictDetector.checkConflict(Comparison, Diff, Iterable)` in order to detect conflicts on a Diff that is of type "DELETE" and which is not a containment reference change.
`protected void` DefaultConflictDetector.`checkFeatureMoveConflict(Comparison comparison, Diff diff, Iterable<Diff> candidates)` This will be called from `DefaultConflictDetector.checkConflict(Comparison, Diff, Iterable)` in order to detect conflicts on a Diff that is of type "CHANGE" or "MOVE".
`protected void` DefaultConflictDetector.`conflictOn(Comparison comparison, Diff diff1, Diff diff2, ConflictKind kind)` This will be called whenever we detect a new conflict in order to create (or update) the actual association.

Method parameters in org.eclipse.emf.compare.conflict with type arguments of type Diff
`protected void` DefaultConflictDetector.`checkConflict(Comparison comparison, Diff diff, Iterable<Diff> candidates)` This will be called once for each difference in the comparison model.
`protected void` DefaultConflictDetector.`checkFeatureAddConflict(Comparison comparison, Diff diff, Iterable<Diff> candidates)` This will be called from `DefaultConflictDetector.checkConflict(Comparison, Diff, Iterable)` in order to detect conflicts on a Diff that is of type "ADD" and which is not a containment reference change.
`protected void` DefaultConflictDetector.`checkFeatureChangeConflict(Comparison comparison, Diff diff, Iterable<Diff> candidates)` This will be called from `DefaultConflictDetector.checkConflict(Comparison, Diff, Iterable)` in order to detect conflicts on a Diff that is of type "CHANGE".
`protected void` DefaultConflictDetector.`checkFeatureDeleteConflict(Comparison comparison, Diff diff, Iterable<Diff> candidates)` This will be called from `DefaultConflictDetector.checkConflict(Comparison, Diff, Iterable)` in order to detect conflicts on a Diff that is of type "DELETE" and which is not a containment reference change.
`protected void` DefaultConflictDetector.`checkFeatureMoveConflict(Comparison comparison, Diff diff, Iterable<Diff> candidates)` This will be called from `DefaultConflictDetector.checkConflict(Comparison, Diff, Iterable)` in order to detect conflicts on a Diff that is of type "CHANGE" or "MOVE".
`protected void` DefaultConflictDetector.`checkResourceAttachmentConflict(Comparison comparison, ResourceAttachmentChange diff, Iterable<Diff> candidates)` This will be called once for each ResourceAttachmentChange in the comparison model.

### Uses of Diff in org.eclipse.emf.compare.domain

Method parameters in org.eclipse.emf.compare.domain with type arguments of type Diff
`Command` ICompareEditingDomain.`createCopyCommand(List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry)` Deprecated.
`ICompareCopyCommand` ICompareEditingDomain.`createCopyCommand(List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry, IMergeRunnable runnable)` Creates a new command that will execute the given `IMergeRunnable` that is expected to merge the given differences in from right to left or left to right by using the mergers defined in the given merger registry.
`void` IMergeRunnable.`merge(List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry)` Execute the merge operation.

### Uses of Diff in org.eclipse.emf.compare.domain.impl

Method parameters in org.eclipse.emf.compare.domain.impl with type arguments of type Diff
`Command` EMFCompareEditingDomain.`createCopyCommand(List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry)` Creates a new command that will merge the given differences in from right to left or left to right by using the mergers defined in the given merger registry.
`ICompareCopyCommand` EMFCompareEditingDomain.`createCopyCommand(List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry, IMergeRunnable runnable)` Creates a new command that will execute the given `IMergeRunnable` that is expected to merge the given differences in from right to left or left to right by using the mergers defined in the given merger registry.

### Uses of Diff in org.eclipse.emf.compare.equi

Methods in org.eclipse.emf.compare.equi with parameters of type Diff
`protected void` DefaultEquiEngine.`checkForEquivalences(Comparison comparison, Diff difference)` Checks the potential equivalence from the given `difference`.

### Uses of Diff in org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer

Methods in org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer that return Diff
`protected Diff` EMFCompareContentMergeViewer.`getDiffFrom(IMergeViewer viewer)` Checks the element selected in the given viewer in order to determine whether it can be adapted into a Diff.

### Uses of Diff in org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.text

Methods in org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.text that return Diff
`Diff` EMFCompareTextMergeViewer.EditCommand.`getDiff()` Returns the diff on which this command operates.

Methods in org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.text that return types with arguments of type Diff
`com.google.common.collect.Multimap<DifferenceState,Diff>` EMFCompareTextMergeViewer.EditCommand.`getChangedDiffs()` Returns the state changes to any diffs that this command produced.

Constructors in org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.text with parameters of type Diff
Constructor and Description
`EditCommand(Diff diff, IModelUpdateStrategy modelUpdateStrategy, IMergeViewer.MergeViewerSide side, String newValue)` Creates a new compound command for the given `side`.

### Uses of Diff in org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.tree.provider

Methods in org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.tree.provider that return types with arguments of type Diff
`protected List<? extends Diff>` TreeMergeViewerItemContentProvider.`collectAndFilterDifferences(Iterable<Object> objects, IMergeViewerItemProviderConfiguration configuration)` Determines the differences related to the given objects and filters them according to the `TreeMergeViewerItemContentProvider.visibleContainmentDiffPredicate(IMergeViewerItemProviderConfiguration)`.
`protected Iterable<? extends Diff>` TreeMergeViewerItemContentProvider.`getVisibleContainmentDiffs(EObject object, IMergeViewerItemProviderConfiguration configuration)` Determines all differences regarding the given `object` which are related to a containment reference change and are visible in the viewer.
`protected com.google.common.base.Predicate<Diff>` TreeMergeViewerItemContentProvider.`visibleContainmentDiffPredicate(IMergeViewerItemProviderConfiguration configuration)` Predicate for checking if the given `diff` is visible and itself (or any of its 'refining' diffs) is a containment reference change.
`protected com.google.common.base.Predicate<Diff>` TreeMergeViewerItemContentProvider.`visibleInMergeViewerPredicate(com.google.common.base.Predicate<? super EObject> predicate, IDifferenceGroupProvider groupProvider)` Predicate for checking if the given `diff` is visible in the merge viewer.

Methods in org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.tree.provider with parameters of type Diff
`protected IMergeViewerItem` TreeMergeViewerItemContentProvider.`createMergeViewerItem(Comparison comparison, Diff diff, Match match, IMergeViewer.MergeViewerSide side, AdapterFactory adapterFactory)` Creates the `IMergeViewerItem` from the given data.
`protected IMergeViewerItem` TreeMergeViewerItemContentProvider.`createMergeViewerItem(Comparison comparison, Diff diff, Object left, Object right, Object ancestor, IMergeViewer.MergeViewerSide side, AdapterFactory adapterFactory)` Creates the `IMergeViewerItem` from the given data.
`protected Object` TreeMergeViewerItemContentProvider.`getDiffValue(Diff diff)` Determines the value of the given diff.
`protected boolean` TreeMergeViewerItemContentProvider.`yieldsMergeViewerItem(Comparison comparison, Diff diff, Collection<?> values)` Indicates whether for the given values at least one `IMergeViewerItem` should be created.

Method parameters in org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.tree.provider with type arguments of type Diff
`protected List<IMergeViewerItem>` TreeMergeViewerItemContentProvider.`createInsertionPoints(IMergeViewerItem parent, List<IMergeViewerItem> values, List<? extends Diff> differences, IMergeViewerItemProviderConfiguration configuration)` Creates and inserts the insertion points for the given `values`.

`protected List<IMergeViewerItem>`

TreeMergeViewerItemContentProvider.`createInsertionPoints(IMergeViewerItem parent, List<Object> sideContent, List<Object> oppositeContent, List<Object> ancestorContent, List<? extends IMergeViewerItem> values, List<? extends Diff> differences, IMergeViewerItemProviderConfiguration configuration)`
Creates the insertion points for the given `values` based on the children of each side.

`protected Object` TreeMergeViewerItemContentProvider.`getFirstValue(Iterable<Diff> diffs)` Determines the first non-null value of the given diffs.
`protected boolean` TreeMergeViewerItemContentProvider.`yieldsInsertionPoint(IMergeViewerItem parent, Iterable<? extends Diff> diffs, IMergeViewerItemProviderConfiguration configuration)` Indicates whether for the given diffs at least one `IMergeViewerItem` insertion point should be created.

### Uses of Diff in org.eclipse.emf.compare.ide.ui.internal.logical

Methods in org.eclipse.emf.compare.ide.ui.internal.logical with parameters of type Diff
`protected void` EMFResourceMappingMerger.`doMergeForDiff(Monitor emfMonitor, Set<URI> conflictingURIs, Diff diff, IDiffRelationshipComputer relationshipComputer)`

Method parameters in org.eclipse.emf.compare.ide.ui.internal.logical with type arguments of type Diff
`protected Set<URI>` EMFResourceMappingMerger.`collectConflictingResources(Iterator<Diff> diffIterator)` Iterates over the given diffs to collect the resources they impact.

### Uses of Diff in org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer

Methods in org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer that return types with arguments of type Diff
`Set<Diff>` DependencyData.`getRejections()`
`Set<Diff>` DependencyData.`getRequires()`

Methods in org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer with parameters of type Diff
`Collection<TreeNode>` DependencyData.`getTreeNodes(Diff diff)`

### Uses of Diff in org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions

Methods in org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions that return types with arguments of type Diff
`protected com.google.common.base.Predicate<Diff>` MergeContainedNonConflictingAction.`getDiffPredicate()`
`protected com.google.common.base.Predicate<Diff>` MergeContainedConflictingAction.`getDiffPredicate()`
`protected com.google.common.base.Predicate<Diff>` MergeContainedAction.`getDiffPredicate()`
`protected abstract com.google.common.base.Predicate<Diff>` AbstractMergeContainedAction.`getDiffPredicate()` Return a predicate that filters the {`selected differences` to just those differences this action will actually operate upon.
`List<Diff>` MergeAction.`getSelectedDifferences()` Returns the cached selected differences.
`protected Iterable<Diff>` MergeAction.`getSelectedDifferences(org.eclipse.jface.viewers.IStructuredSelection selection)`
`protected Iterable<Diff>` AbstractMergeContainedAction.`getSelectedDifferences(org.eclipse.jface.viewers.IStructuredSelection selection)`
`protected Iterable<Diff>` MergeAction.`getSelectedDifferences(Iterable<Diff> diffs)`
`protected Iterable<Diff>` MergeAllNonConflictingAction.`getSelectedDifferences(Iterable<Diff> diffs)`
`protected com.google.common.base.Predicate<Diff>` MergeAction.`getStatePredicate()`
`protected com.google.common.base.Predicate<Diff>` MergeContainedConflictingAction.`getStatePredicate()`
`Iterable<Diff>` MergeNonConflictingRunnable.`merge(Comparison comparison, boolean leftToRight, IMerger.Registry mergerRegistry)` Merges all non-conflicting differences from the given comparison in either direction.

Methods in org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions with parameters of type Diff
`protected void` MergeNonConflictingRunnable.`doMergeDiffWithConflicts(boolean leftToRight, IMerger.Registry mergerRegistry, List<Diff> affectedDiffs, Monitor emfMonitor, Diff diff)`
`protected void` AbstractMergeRunnable.`markAsMerged(Diff diff, MergeMode mode, boolean mergeRightToLeft, IMerger.Registry mergerRegistry)` Marks a single diff as merged, keeping track of the merge mode used for the operation.

Method parameters in org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions with type arguments of type Diff
`protected void` MergeNonConflictingRunnable.`doMergeDiffWithConflicts(boolean leftToRight, IMerger.Registry mergerRegistry, List<Diff> affectedDiffs, Monitor emfMonitor, Diff diff)`
`protected void` MergeAction.`execute(ICompareCommandStack commandStack, MergeMode mode, List<Diff> diffs)`
`protected void` MergeAllNonConflictingAction.`execute(ICompareCommandStack commandStack, MergeMode mode, List<Diff> diffs)`
`protected void` MergeAction.`executeCompareCopyCommand(ICompareCommandStack commandStack, MergeMode mode, List<Diff> diffs)`
`protected Iterable<Diff>` MergeAction.`getSelectedDifferences(Iterable<Diff> diffs)`
`protected Iterable<Diff>` MergeAllNonConflictingAction.`getSelectedDifferences(Iterable<Diff> diffs)`
`protected void` AbstractMergeRunnable.`markAllAsMerged(Collection<? extends Diff> diffToMarkAsMerged, MergeMode mode, IMerger.Registry mergerRegistry)` Marks all of the given diffs as merged, keeping track of the merged mode used for the operation.
`void` MergeRunnableImpl.`merge(List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry)`
`void` MergeNonConflictingRunnable.`merge(List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry)` Execute the merge operation.
`void` MergeContainedRunnable.`merge(List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry)`
`void` MergeConflictingRunnable.`merge(List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry)` Execute the merge operation.
`protected void` AbstractMergeRunnable.`mergeAll(Collection<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry)`

Constructors in org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions with parameters of type Diff
Constructor and Description
`RevealConflictingDiffsAction(org.eclipse.jface.viewers.StructuredViewer viewer, Diff selectedDiff, IEMFCompareConfiguration compareConfiguration)`

### Uses of Diff in org.eclipse.emf.compare.impl

Classes in org.eclipse.emf.compare.impl that implement Diff
`class` `AttributeChangeImpl` An implementation of the model object 'Attribute Change'
`class` `DiffImpl` An implementation of the model object 'Diff'.
`class` `FeatureMapChangeImpl` An implementation of the model object 'Feature Map Change'
`class` `ReferenceChangeImpl` An implementation of the model object 'Reference Change'
`class` `ResourceAttachmentChangeImpl` An implementation of the model object 'Resource Attachment Change'
`class` `ResourceLocationChangeImpl` An implementation of the model object 'Resource Location Change'

Fields in org.eclipse.emf.compare.impl declared as Diff
`protected Diff` DiffImpl.`primeRefining` The cached value of the '`Prime Refining`' reference.

Fields in org.eclipse.emf.compare.impl with type parameters of type Diff
`protected EList<Diff>` MatchImpl.`differences` The cached value of the '`Differences`' containment reference list
`protected EList<Diff>` EquivalenceImpl.`differences` The cached value of the '`Differences`' reference list
`protected EList<Diff>` ConflictImpl.`differences` The cached value of the '`Differences`' reference list
`protected EList<Diff>` DiffImpl.`impliedBy` The cached value of the '`Implied By`' reference list.
`protected EList<Diff>` DiffImpl.`implies` The cached value of the '`Implies`' reference list
`protected EList<Diff>` DiffImpl.`refinedBy` The cached value of the '`Refined By`' reference list.
`protected EList<Diff>` DiffImpl.`refines` The cached value of the '`Refines`' reference list
`protected EList<Diff>` DiffImpl.`requiredBy` The cached value of the '`Required By`' reference list.
`protected EList<Diff>` DiffImpl.`requires` The cached value of the '`Requires`' reference list

Methods in org.eclipse.emf.compare.impl that return Diff
`Diff` DiffImpl.`basicGetPrimeRefining()`
`Diff` CompareFactoryImpl.`createDiff()`
`Diff` DiffImpl.`getPrimeRefining()`

Methods in org.eclipse.emf.compare.impl that return types with arguments of type Diff
`Iterable<Diff>` MatchImpl.`getAllDifferences()`
`EList<Diff>` MatchImpl.`getDifferences()`
`EList<Diff>` EquivalenceImpl.`getDifferences()`
`EList<Diff>` ConflictImpl.`getDifferences()`
`EList<Diff>` ComparisonImpl.`getDifferences()`
`EList<Diff>` ComparisonImpl.`getDifferences(EObject element)`
`EList<Diff>` DiffImpl.`getImpliedBy()`
`EList<Diff>` DiffImpl.`getImplies()`
`EList<Diff>` ConflictImpl.`getLeftDifferences()`
`EList<Diff>` DiffImpl.`getRefinedBy()`
`EList<Diff>` DiffImpl.`getRefines()`
`EList<Diff>` DiffImpl.`getRequiredBy()`
`EList<Diff>` DiffImpl.`getRequires()`
`EList<Diff>` ConflictImpl.`getRightDifferences()`

### Uses of Diff in org.eclipse.emf.compare.internal.conflict

Classes in org.eclipse.emf.compare.internal.conflict with type parameters of type Diff
`class` `AbstractConflictSearch<T extends Diff>` Class in charge of finding conflicting diffs for a given diff of type T.

Fields in org.eclipse.emf.compare.internal.conflict declared as Diff
`protected T` AbstractConflictSearch.`diff` The difference, never `null`.

Methods in org.eclipse.emf.compare.internal.conflict that return Diff
`Diff` DiffTreeIterator.`next()`

Methods in org.eclipse.emf.compare.internal.conflict that return types with arguments of type Diff
`AbstractConflictSearch<? extends Diff>` ConflictSearchFactory.`caseFeatureMapChange(FeatureMapChange diff)`
`AbstractConflictSearch<? extends Diff>` ConflictSearchFactory.`caseReferenceChange(ReferenceChange diff)`
`AbstractConflictSearch<? extends Diff>` ConflictSearchFactory.`caseResourceAttachmentChange(ResourceAttachmentChange diff)`
`protected EList<Diff>` AbstractConflictSearch.`getDiffsInSameMatch()` Get the diffs in the same `Match` as diff.

Methods in org.eclipse.emf.compare.internal.conflict with parameters of type Diff
`protected boolean` AbstractConflictSearch.`areMergeableStringAttributeChanges(Diff diff1, Diff diff2)` Specifies whether the two given diffs, `diff1` and `diff2`, are both `attribute changes` of String attributes and can be merged with a line-based three-way merge.
`protected void` AbstractConflictSearch.`conflict(Diff other, ConflictKind kind)` This will be called whenever we detect a new conflict in order to create (or update) the actual association.
`protected boolean` AbstractConflictSearch.`isFeatureMapChange(Diff toCheck)` Specifies whether the given `diff` is a `FeatureMapChange`.
`protected boolean` AbstractConflictSearch.`isFeatureMapChangeOrMergeableStringAttributeChange(Diff diff1, Diff diff2)` Specifies whether the given `diff1` and `diff2` are either `feature map changes` or mergeable `attribute changes` of String attributes.
`protected boolean` AbstractConflictSearch.`isStringAttributeChange(Diff toCheck)` Specifies whether the given `diff` is a `AttributeChange` of a String attribute.

Method parameters in org.eclipse.emf.compare.internal.conflict with type arguments of type Diff
`void` DiffTreeIterator.`setFilter(com.google.common.base.Predicate<? super Diff> filter)` Sets the criterion that Diffs must meet to be returned by this iterator.

### Uses of Diff in org.eclipse.emf.compare.internal.domain

Methods in org.eclipse.emf.compare.internal.domain that return types with arguments of type Diff
`Iterable<Diff>` IMergeAllNonConflictingRunnable.`merge(Comparison comparison, boolean leftToRight, IMerger.Registry mergerRegistry)` Merges all non-conflicting differences from the given comparison in either direction.

### Uses of Diff in org.eclipse.emf.compare.internal.merge

Methods in org.eclipse.emf.compare.internal.merge with parameters of type Diff
`MergeOperation` MergeMode.`getMergeAction(Diff difference, boolean isLeftEditable, boolean isRightEditable)` Returns the required action to be done to the given difference in this mode.
`static MergeMode` MergeMode.`getMergeMode(Diff diff, boolean leftEditable, boolean rightEditable)`
`boolean` MergeMode.`isLeftToRight(Diff diff, boolean isLeftEditable, boolean isRightEditable)` To exactly know the way of merge (to compute consequences) we need the source of the diff.

### Uses of Diff in org.eclipse.emf.compare.internal.postprocessor.factories

Methods in org.eclipse.emf.compare.internal.postprocessor.factories that return Diff
`Diff` IChangeFactory.`create(Diff input)` Creates and returns a `extension` from the given `Diff`.
`Diff` AbstractChangeFactory.`create(Diff input)` Creates and returns a `extension` from the given `Diff`.
`abstract Diff` AbstractChangeFactory.`createExtension()` It creates the graphical change extension.

Methods in org.eclipse.emf.compare.internal.postprocessor.factories that return types with arguments of type Diff
`protected List<Diff>` AbstractChangeFactory.`findCrossReferences(Comparison comparison, EObject lookup, com.google.common.base.Predicate<Diff> p)` Find the differences, on the given model object, which match with the predicate.
`protected Set<Diff>` AbstractChangeFactory.`getAllContainedDifferences(Diff input)` Get all the add and delete changes on the objects contained in the one concerned by the given difference.
`Class<? extends Diff>` IChangeFactory.`getExtensionKind()` Returns the kind of extension that this factory has to create.
`Class<? extends Diff>` AbstractChangeFactory.`getExtensionKind()` Returns the kind of extension that this factory has to create.

Methods in org.eclipse.emf.compare.internal.postprocessor.factories with parameters of type Diff
`Diff` IChangeFactory.`create(Diff input)` Creates and returns a `extension` from the given `Diff`.
`Diff` AbstractChangeFactory.`create(Diff input)` Creates and returns a `extension` from the given `Diff`.
`void` IChangeFactory.`fillRequiredDifferences(Comparison comparison, Diff extension)` Sets the required link of the difference extension created by the related factory.
`void` AbstractChangeFactory.`fillRequiredDifferences(Comparison comparison, Diff extension)` Sets the required link of the difference extension created by the related factory.
`protected Set<Diff>` AbstractChangeFactory.`getAllContainedDifferences(Diff input)` Get all the add and delete changes on the objects contained in the one concerned by the given difference.
`Match` IChangeFactory.`getParentMatch(Diff input)` Returns the match in which the difference will be added.
`Match` AbstractChangeFactory.`getParentMatch(Diff input)` Returns the match in which the difference will be added.
`protected DifferenceKind` AbstractChangeFactory.`getRelatedExtensionKind(Diff input)` Get the `DifferenceKind` of the matching diagram difference extension in relation to the given difference.
`boolean` IChangeFactory.`handles(Diff input)` Returns true if this factory handles the given kind of Diff, i.e., if it can create an `extension`.
`boolean` AbstractChangeFactory.`handles(Diff input)` Returns true if this factory handles the given kind of Diff, i.e., if it can create an `extension`.
`abstract void` AbstractChangeFactory.`setRefiningChanges(Diff extension, DifferenceKind extensionKind, Diff refiningDiff)` Get the refining differences and set the given extension with them, from the given refining one.

Method parameters in org.eclipse.emf.compare.internal.postprocessor.factories with type arguments of type Diff
`protected List<Diff>` AbstractChangeFactory.`findCrossReferences(Comparison comparison, EObject lookup, com.google.common.base.Predicate<Diff> p)` Find the differences, on the given model object, which match with the predicate.

### Uses of Diff in org.eclipse.emf.compare.internal.spec

Classes in org.eclipse.emf.compare.internal.spec that implement Diff
`class` `AttributeChangeSpec` This specialization of the `AttributeChangeImpl` class allows us to define the derived features and operations implementations.
`class` `DiffSpec` This specialization of the `DiffImpl` class allows us to define the derived features and operations implementations.
`class` `FeatureMapChangeSpec` This specialization of the `FeatureMapChangeImpl` class allows us to define the derived features and operations implementations.
`class` `ReferenceChangeSpec` This specialization of the `ReferenceChangeImpl` class allows us to define the derived features and operations implementations.
`class` `ResourceAttachmentChangeSpec` This specialization of the `ResourceAttachmentChangeImpl` class allows us to define the derived features and operations implementations.
`class` `ResourceLocationChangeSpec` This specialization of the `ResourceLocationChangeImpl` class allows us to define the derived features and operations implementations.

Methods in org.eclipse.emf.compare.internal.spec that return types with arguments of type Diff
`Iterable<Diff>` MatchSpec.`getAllDifferences()` Finds and returns all differences contained in this Match and its children, recursively
`EList<Diff>` ComparisonSpec.`getDifferences()`
`EList<Diff>` ComparisonSpec.`getDifferences(EObject element)`
`EList<Diff>` ConflictSpec.`getLeftDifferences()` This can be used to retrieve the list of differences that were made in the left element
`EList<Diff>` ConflictSpec.`getRightDifferences()` This can be used to retrieve the list of differences that were made in the right element

### Uses of Diff in org.eclipse.emf.compare.internal.utils

Methods in org.eclipse.emf.compare.internal.utils that return types with arguments of type Diff
`static Set<Diff>` DiffUtil.`getAllAtomicRefiningDiffs(Diff diff)` The set of all the atomic diffs that refine the given diff or one of its refining diffs, recursively.
`static Set<Diff>` DiffUtil.`getAllRefiningDiffs(Diff diff)` The set of all the diffs (atomic or not) that refine the given diff or one of its refining diffs, recursively.
`static com.google.common.base.Function<Diff,Iterable<Diff>>` ComparisonUtil.`getDirectSubDiffs(boolean leftToRight)` When merging a `Diff`, returns the first level of sub diffs of this given diff, and all associated diffs (see `DiffUtil#getAssociatedDiffs(Iterable, boolean, Diff)`) of these sub diffs.
`static com.google.common.base.Function<Diff,Iterable<Diff>>` ComparisonUtil.`getDirectSubDiffs(boolean leftToRight)` When merging a `Diff`, returns the first level of sub diffs of this given diff, and all associated diffs (see `DiffUtil#getAssociatedDiffs(Iterable, boolean, Diff)`) of these sub diffs.
`static List<Diff>` DiffUtil.`getRootRefinedDiffs(Diff diff)` Determines the root refined diff of a refining diff, i.e. a refined diff that is not refining another diff.
`static com.google.common.base.Function<Diff,Iterable<Diff>>` ComparisonUtil.`getSubDiffs(boolean leftToRight)` When merging a `Diff`, returns the sub diffs of this given diff, and all associated diffs (see `DiffUtil#getAssociatedDiffs(Iterable, boolean, Diff)`) of these sub diffs.
`static com.google.common.base.Function<Diff,Iterable<Diff>>` ComparisonUtil.`getSubDiffs(boolean leftToRight)` When merging a `Diff`, returns the sub diffs of this given diff, and all associated diffs (see `DiffUtil#getAssociatedDiffs(Iterable, boolean, Diff)`) of these sub diffs.

Methods in org.eclipse.emf.compare.internal.utils with parameters of type Diff
`static void` ComparisonUtil.`delete(Diff diff)` `Deletes` the given `diff`.
`static int` DiffUtil.`findInsertionIndex(Comparison comparison, Diff diff, boolean rightToLeft)` This is the main entry point for `DiffUtil.findInsertionIndex(Comparison, Iterable, List, List, Object)`.
`static Set<Diff>` DiffUtil.`getAllAtomicRefiningDiffs(Diff diff)` The set of all the atomic diffs that refine the given diff or one of its refining diffs, recursively.
`static Set<Diff>` DiffUtil.`getAllRefiningDiffs(Diff diff)` The set of all the diffs (atomic or not) that refine the given diff or one of its refining diffs, recursively.
`static Comparison` ComparisonUtil.`getComparison(Diff diff)` Returns the comparison associated with the given diff.
`static List<Diff>` DiffUtil.`getRootRefinedDiffs(Diff diff)` Determines the root refined diff of a refining diff, i.e. a refined diff that is not refining another diff.
`static boolean` ComparisonUtil.`isAddOrSetDiff(Diff difference)` Checks if the given difference is either an addition or a "set" from the default value to a new reference.
`static boolean` ComparisonUtil.`isDeleteOrUnsetDiff(Diff difference)` Checks if the given difference is either a deletion or a "unset" to the default value.
`static boolean` ComparisonUtil.`isFeatureMapContainment(Diff diff)` Checks whether the given diff corresponds to a feature map containment change.

### Uses of Diff in org.eclipse.emf.compare.merge

Fields in org.eclipse.emf.compare.merge with type parameters of type Diff
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directMergeDependenciesL2R` Direct merge dependencies: left to right.
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directMergeDependenciesL2R` Direct merge dependencies: left to right.
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directMergeDependenciesR2L` Direct merge dependencies: right to left.
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directMergeDependenciesR2L` Direct merge dependencies: right to left.
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directResultingMergesL2R` Direct resulting merges: left to right.
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directResultingMergesL2R` Direct resulting merges: left to right.
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directResultingMergesR2L` Direct resulting merges: right to left.
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directResultingMergesR2L` Direct resulting merges: right to left.
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directResultingRejectionsL2R` Direct resulting rejections: left to right.
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directResultingRejectionsL2R` Direct resulting rejections: left to right.
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directResultingRejectionsR2L` Direct resulting rejections: right to left.
`protected Map<Diff,Set<Diff>>` CachingDiffRelationshipComputer.`directResultingRejectionsR2L` Direct resulting rejections: right to left.

Methods in org.eclipse.emf.compare.merge that return types with arguments of type Diff
`protected Set<Diff>` CachingDiffRelationshipComputer.`computeDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Computes direct merge dependencies for the given diff.
`protected Set<Diff>` CachingDiffRelationshipComputer.`computeDirectResultingMerges(Diff diff, boolean mergeRightToLeft)` Computes direct resulting merges for the given diff.
`protected Set<Diff>` CachingDiffRelationshipComputer.`computeDirectResultingRejections(Diff diff, boolean mergeRightToLeft)` Computes the direct resulting rejections.
`Set<Diff>` ComputeDiffsToMerge.`getAllDiffsToMerge(Diff diff)` Compute the ordered set of diffs to merge for the given diff.
`Set<Diff>` ComputeDiffsToMerge.`getAllDiffsToMerge(Iterable<? extends Diff> diffs)` Compute the ordered set of diffs to merge for the given diffs.
`Set<Diff>` IDiffRelationshipComputer.`getAllResultingMerges(Diff diff, boolean rightToLeft)` Retrieves the set of all diffs related to the given `diff` when merging in the given direction.
`Set<Diff>` DiffRelationshipComputer.`getAllResultingMerges(Diff diff, boolean rightToLeft)`
`Set<Diff>` IDiffRelationshipComputer.`getAllResultingMerges(Diff diff, boolean rightToLeft, com.google.common.base.Predicate<? super Diff> filter)` Retrieves the set of all diffs related to the given `diff` when merging in the given direction.
`Set<Diff>` DiffRelationshipComputer.`getAllResultingMerges(Diff diff, boolean rightToLeft, com.google.common.base.Predicate<? super Diff> filter)`
`Set<Diff>` IDiffRelationshipComputer.`getAllResultingRejections(Diff diff, boolean mergeRightToLeft)` Retrieves the set of all diffs that will be rejected if the given `diff` is merged, either because of unresolveable conflicts or because of unreachable requirements.
`Set<Diff>` DiffRelationshipComputer.`getAllResultingRejections(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` IDiffRelationshipComputer.`getAllResultingRejections(Diff diff, boolean mergeRightToLeft, com.google.common.base.Predicate<? super Diff> filter)` Retrieves the set of all diffs that will be rejected if the given `diff` is merged, either because of unresolveable conflicts or because of unreachable requirements.
`Set<Diff>` DiffRelationshipComputer.`getAllResultingRejections(Diff diff, boolean mergeRightToLeft, com.google.common.base.Predicate<? super Diff> filter)`
`protected Set<Diff>` CachingDiffRelationshipComputer.`getCachedDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Returns the cached direct merge dependencies.
`protected Set<Diff>` CachingDiffRelationshipComputer.`getCachedDirectResultingMerges(Diff diff, boolean mergeRightToLeft)` Returns the cached direct resulting merges.
`protected Set<Diff>` CachingDiffRelationshipComputer.`getCachedDirectResultingRejections(Diff diff, boolean mergeRightToLeft)` Returns the cached direct resulting rejections.
`Collection<Diff>` MergeBlockedByConflictException.`getConflictingDiffs()` Get the conflicting diffs.
`Set<Diff>` IMerger2.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Retrieves the set of directly required diffs needed in order to merge the current one.
`Set<Diff>` IDiffRelationshipComputer.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Retrieves the set of directly required diffs needed in order to merge the given `diff`.
`Set<Diff>` DiffRelationshipComputer.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` ConflictMerger.`getDirectMergeDependencies(Diff diff, boolean rightToLeft)`
`Set<Diff>` CachingDiffRelationshipComputer.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Returns the cached direct merge dependencies, if present.
`Set<Diff>` AdditiveResourceAttachmentChangeMerger.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` AdditiveReferenceChangeMerger.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` AdditiveConflictMerger.`getDirectMergeDependencies(Diff target, boolean mergeRightToLeft)`
`Set<Diff>` AbstractMerger.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Retrieves the set of directly required diffs needed in order to merge the current one.
`Set<Diff>` IMerger2.`getDirectResultingMerges(Diff target, boolean mergeRightToLeft)` Returns all differences that will be merged because of our merging the given `target` difference.
`Set<Diff>` IDiffRelationshipComputer.`getDirectResultingMerges(Diff diff, boolean mergeRightToLeft)` Returns all differences that will be merged because of our merging the given `diff`.
`Set<Diff>` DiffRelationshipComputer.`getDirectResultingMerges(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` ConflictMerger.`getDirectResultingMerges(Diff diff, boolean rightToLeft)`
`Set<Diff>` CachingDiffRelationshipComputer.`getDirectResultingMerges(Diff diff, boolean mergeRightToLeft)` Returns the cached direct resulting merges, if present.
`Set<Diff>` AdditiveResourceAttachmentChangeMerger.`getDirectResultingMerges(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` AdditiveReferenceChangeMerger.`getDirectResultingMerges(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` AdditiveConflictMerger.`getDirectResultingMerges(Diff target, boolean mergeRightToLeft)`
`Set<Diff>` AbstractMerger.`getDirectResultingMerges(Diff target, boolean mergeRightToLeft)` Returns all differences that will be merged because of our merging the given `target` difference.
`Set<Diff>` IMerger2.`getDirectResultingRejections(Diff target, boolean mergeRightToLeft)` Returns the set of all differences that need to be rejected if `target` is merged in the given direction.
`Set<Diff>` IDiffRelationshipComputer.`getDirectResultingRejections(Diff diff, boolean mergeRightToLeft)` Returns the set of all differences that need to be rejected if `diff` is merged in the given direction.
`Set<Diff>` DiffRelationshipComputer.`getDirectResultingRejections(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` CachingDiffRelationshipComputer.`getDirectResultingRejections(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` AbstractMerger.`getDirectResultingRejections(Diff target, boolean rightToLeft)` Returns the set of all differences that need to be rejected if `target` is merged in the given direction.
`protected Set<Diff>` AbstractMerger.`getImpliedMerges(Diff target, boolean mergeRightToLeft)` Returns all differences that are automatically set to the targets `state` if the given target diff is merged.
`protected Set<Diff>` AbstractMerger.`getLogicallyResultingMerges(Diff diff, boolean mergeRightToLeft)` Returns a set of differences that should be logically merged with the given diff.
`protected Set<Diff>` DiffRelationshipComputer.`internalGetAllResultingMerges(Diff diff, boolean rightToLeft)` Returns the set of all differences directly related to the given one, either as dependencies or as implications.

Methods in org.eclipse.emf.compare.merge with parameters of type Diff
`protected void` ResourceLocationChangeMerger.`accept(Diff diff, boolean rightToLeft)` Deprecated.
`protected void` ResourceAttachmentChangeMerger.`accept(Diff diff, boolean rightToLeft)` Accept the given difference.
`protected void` ReferenceChangeMerger.`accept(Diff diff, boolean rightToLeft)` Merge the given difference accepting it.
`protected void` FeatureMapChangeMerger.`accept(Diff diff, boolean rightToLeft)` Accept the given difference.
`protected void` AttributeChangeMerger.`accept(Diff diff, boolean rightToLeft)` Accept the given difference.
`protected void` AbstractMerger.`accept(Diff diff, boolean rightToLeft)` Accept the given difference.
`protected void` ComputeDiffsToMerge.`addDiff(Diff diff)` Compute the ordered set of diffs for the given diff.
`protected void` ComputeDiffsToMerge.`addDiff(Diff diff, Set<Diff> consequences, Set<Diff> diffPath)` Recursively add the required diffs, then the diff itself, to the result.
`void` CachingDiffRelationshipComputer.`computeCache(Diff diff)` Computes the cached relationships for the give diff.
`protected Set<Diff>` CachingDiffRelationshipComputer.`computeDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Computes direct merge dependencies for the given diff.
`protected Set<Diff>` CachingDiffRelationshipComputer.`computeDirectResultingMerges(Diff diff, boolean mergeRightToLeft)` Computes direct resulting merges for the given diff.
`protected Set<Diff>` CachingDiffRelationshipComputer.`computeDirectResultingRejections(Diff diff, boolean mergeRightToLeft)` Computes the direct resulting rejections.
`protected void` AbstractMerger.`copyDiff(Diff target, Monitor monitor, boolean rightToLeft)` Executes a copy in the given merge direction.
`void` PseudoConflictMerger.`copyLeftToRight(Diff target, Monitor monitor)` Executes the copy from left to right.
`void` IMerger.`copyLeftToRight(Diff target, Monitor monitor)` Executes the copy from left to right.
`void` DelegatingMerger.`copyLeftToRight(Diff target, Monitor monitor)` Call copyLeftToRight on the wrapped merger with the right criterion.
`void` ConflictMerger.`copyLeftToRight(Diff target, Monitor monitor)` Executes the copy from left to right.
`void` AbstractMerger.`copyLeftToRight(Diff target, Monitor monitor)` Executes the copy from left to right.
`void` PseudoConflictMerger.`copyRightToLeft(Diff target, Monitor monitor)` Executes the copy from right to left.
`void` IMerger.`copyRightToLeft(Diff target, Monitor monitor)` Executes the copy from right to left.
`void` DelegatingMerger.`copyRightToLeft(Diff target, Monitor monitor)` Call copyRightToLeft on the wrapped merger with the right criterion.
`void` ConflictMerger.`copyRightToLeft(Diff target, Monitor monitor)` Executes the copy from right to left.
`void` AdditiveResourceAttachmentChangeMerger.`copyRightToLeft(Diff target, Monitor monitor)`
`void` AdditiveReferenceChangeMerger.`copyRightToLeft(Diff target, Monitor monitor)`
`void` AdditiveConflictMerger.`copyRightToLeft(Diff target, Monitor monitor)`
`void` AbstractMerger.`copyRightToLeft(Diff target, Monitor monitor)` Executes the copy from right to left.
`protected int` ReferenceChangeMerger.`findInsertionIndex(Comparison comparison, Diff diff, boolean rightToLeft)` This will be used by the distinct merge actions in order to find the index at which a value should be inserted in its target list.
`protected int` FeatureMapChangeMerger.`findInsertionIndex(Comparison comparison, Diff diff, boolean rightToLeft)` This will be used by the distinct merge actions in order to find the index at which a value should be inserted in its target list.
`protected int` AttributeChangeMerger.`findInsertionIndex(Comparison comparison, Diff diff, boolean rightToLeft)` This will be used by the distinct merge actions in order to find the index at which a value should be inserted in its target list.
`Set<Diff>` ComputeDiffsToMerge.`getAllDiffsToMerge(Diff diff)` Compute the ordered set of diffs to merge for the given diff.
`Set<Diff>` IDiffRelationshipComputer.`getAllResultingMerges(Diff diff, boolean rightToLeft)` Retrieves the set of all diffs related to the given `diff` when merging in the given direction.
`Set<Diff>` DiffRelationshipComputer.`getAllResultingMerges(Diff diff, boolean rightToLeft)`
`Set<Diff>` IDiffRelationshipComputer.`getAllResultingMerges(Diff diff, boolean rightToLeft, com.google.common.base.Predicate<? super Diff> filter)` Retrieves the set of all diffs related to the given `diff` when merging in the given direction.
`Set<Diff>` DiffRelationshipComputer.`getAllResultingMerges(Diff diff, boolean rightToLeft, com.google.common.base.Predicate<? super Diff> filter)`
`Set<Diff>` IDiffRelationshipComputer.`getAllResultingRejections(Diff diff, boolean mergeRightToLeft)` Retrieves the set of all diffs that will be rejected if the given `diff` is merged, either because of unresolveable conflicts or because of unreachable requirements.
`Set<Diff>` DiffRelationshipComputer.`getAllResultingRejections(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` IDiffRelationshipComputer.`getAllResultingRejections(Diff diff, boolean mergeRightToLeft, com.google.common.base.Predicate<? super Diff> filter)` Retrieves the set of all diffs that will be rejected if the given `diff` is merged, either because of unresolveable conflicts or because of unreachable requirements.
`Set<Diff>` DiffRelationshipComputer.`getAllResultingRejections(Diff diff, boolean mergeRightToLeft, com.google.common.base.Predicate<? super Diff> filter)`
`protected Set<Diff>` CachingDiffRelationshipComputer.`getCachedDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Returns the cached direct merge dependencies.
`protected Set<Diff>` CachingDiffRelationshipComputer.`getCachedDirectResultingMerges(Diff diff, boolean mergeRightToLeft)` Returns the cached direct resulting merges.
`protected Set<Diff>` CachingDiffRelationshipComputer.`getCachedDirectResultingRejections(Diff diff, boolean mergeRightToLeft)` Returns the cached direct resulting rejections.
`Set<Diff>` IMerger2.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Retrieves the set of directly required diffs needed in order to merge the current one.
`Set<Diff>` IDiffRelationshipComputer.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Retrieves the set of directly required diffs needed in order to merge the given `diff`.
`Set<Diff>` DiffRelationshipComputer.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` ConflictMerger.`getDirectMergeDependencies(Diff diff, boolean rightToLeft)`
`Set<Diff>` CachingDiffRelationshipComputer.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Returns the cached direct merge dependencies, if present.
`Set<Diff>` AdditiveResourceAttachmentChangeMerger.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` AdditiveReferenceChangeMerger.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` AdditiveConflictMerger.`getDirectMergeDependencies(Diff target, boolean mergeRightToLeft)`
`Set<Diff>` AbstractMerger.`getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Retrieves the set of directly required diffs needed in order to merge the current one.
`Set<Diff>` IMerger2.`getDirectResultingMerges(Diff target, boolean mergeRightToLeft)` Returns all differences that will be merged because of our merging the given `target` difference.
`Set<Diff>` IDiffRelationshipComputer.`getDirectResultingMerges(Diff diff, boolean mergeRightToLeft)` Returns all differences that will be merged because of our merging the given `diff`.
`Set<Diff>` DiffRelationshipComputer.`getDirectResultingMerges(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` ConflictMerger.`getDirectResultingMerges(Diff diff, boolean rightToLeft)`
`Set<Diff>` CachingDiffRelationshipComputer.`getDirectResultingMerges(Diff diff, boolean mergeRightToLeft)` Returns the cached direct resulting merges, if present.
`Set<Diff>` AdditiveResourceAttachmentChangeMerger.`getDirectResultingMerges(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` AdditiveReferenceChangeMerger.`getDirectResultingMerges(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` AdditiveConflictMerger.`getDirectResultingMerges(Diff target, boolean mergeRightToLeft)`
`Set<Diff>` AbstractMerger.`getDirectResultingMerges(Diff target, boolean mergeRightToLeft)` Returns all differences that will be merged because of our merging the given `target` difference.
`Set<Diff>` IMerger2.`getDirectResultingRejections(Diff target, boolean mergeRightToLeft)` Returns the set of all differences that need to be rejected if `target` is merged in the given direction.
`Set<Diff>` IDiffRelationshipComputer.`getDirectResultingRejections(Diff diff, boolean mergeRightToLeft)` Returns the set of all differences that need to be rejected if `diff` is merged in the given direction.
`Set<Diff>` DiffRelationshipComputer.`getDirectResultingRejections(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` CachingDiffRelationshipComputer.`getDirectResultingRejections(Diff diff, boolean mergeRightToLeft)`
`Set<Diff>` AbstractMerger.`getDirectResultingRejections(Diff target, boolean rightToLeft)` Returns the set of all differences that need to be rejected if `target` is merged in the given direction.
`IMerger` IMerger.Registry.`getHighestRankingMerger(Diff target)` Returns the merger, for the given target, owning the highest ranking.
`IMerger` IMerger.RegistryImpl.`getHighestRankingMerger(Diff target)` Returns the merger, for the given target, owning the highest ranking.
`protected Set<Diff>` AbstractMerger.`getImpliedMerges(Diff target, boolean mergeRightToLeft)` Returns all differences that are automatically set to the targets `state` if the given target diff is merged.
`protected Set<Diff>` AbstractMerger.`getLogicallyResultingMerges(Diff diff, boolean mergeRightToLeft)` Returns a set of differences that should be logically merged with the given diff.
`IMerger2` IDiffRelationshipComputer.`getMerger(Diff diff)` Returns the best-fitting merger for the given diff according to the `merger registry` and the `merge criterion`.
`IMerger2` DiffRelationshipComputer.`getMerger(Diff diff)`
`protected DelegatingMerger` ConflictMerger.`getMergerDelegate(Diff diff)`
`protected DelegatingMerger` AbstractMerger.`getMergerDelegate(Diff diff)` Find the best merger for diff and wrap it in a delegate that will take the current merge criterion into account.
`static DelegatingMerger` AbstractMerger.`getMergerDelegate(Diff diff, IMerger.Registry2 registry, IMergeCriterion criterion)` Find the best merger for diff and wrap it in a delegate that will take the given merge criterion into account.
`Collection<IMerger>` IMerger.Registry.`getMergers(Diff target)` Returns the list of the candidate mergers for the given difference.
`Collection<IMerger>` IMerger.RegistryImpl.`getMergers(Diff target)` Returns the list of the candidate mergers for the given difference.
`Iterator<IMerger>` IMerger.Registry2.`getMergersByRankDescending(Diff diff, IMergeCriterion criterion)` Provide the merger with the highest ranking among those that: Are compatible with the given diff; Match the given non-null criterion.
`Iterator<IMerger>` IMerger.RegistryImpl.`getMergersByRankDescending(Diff diff, IMergeCriterion criterion)` Provide the mergers sorted by rank descending.
`boolean` IDiffRelationshipComputer.`hasMerger(Diff diff)` Indicates whether a best-fitting merger for the given diff is available.
`boolean` DiffRelationshipComputer.`hasMerger(Diff diff)`
`protected Set<Diff>` DiffRelationshipComputer.`internalGetAllResultingMerges(Diff diff, boolean rightToLeft)` Returns the set of all differences directly related to the given one, either as dependencies or as implications.
`static boolean` AbstractMerger.`isAccepting(Diff diff, boolean mergeRightToLeft)` Checks whether the given merge direction will result in accepting this difference based on the difference's `source`.
`static boolean` AbstractMerger.`isInTerminalState(Diff target)` Returns whether the given difference is in a terminal state or not.
`boolean` ResourceLocationChangeMerger.`isMergerFor(Diff target)` Deprecated. Check if the merger is a good candidate to merge the given difference.
`boolean` ResourceAttachmentChangeMerger.`isMergerFor(Diff target)` Check if the merger is a good candidate to merge the given difference.
`boolean` ReferenceChangeMerger.`isMergerFor(Diff target)` Check if the merger is a good candidate to merge the given difference.
`boolean` PseudoConflictMerger.`isMergerFor(Diff target)` Check if the merger is a good candidate to merge the given difference.
`boolean` IMerger.`isMergerFor(Diff target)` Check if the merger is a good candidate to merge the given difference.
`boolean` FeatureMapChangeMerger.`isMergerFor(Diff target)` Check if the merger is a good candidate to merge the given difference.
`boolean` ConflictMerger.`isMergerFor(Diff target)` Check if the merger is a good candidate to merge the given difference.
`boolean` AttributeChangeMerger.`isMergerFor(Diff target)` Check if the merger is a good candidate to merge the given difference.
`protected void` AbstractMerger.`mergeDiff(Diff diff, boolean rightToLeft, Monitor monitor)` This can be used by mergers to merge another (required, equivalent...) difference using the right merger for that diff.
`protected void` ResourceLocationChangeMerger.`reject(Diff diff, boolean rightToLeft)` Deprecated.
`protected void` ResourceAttachmentChangeMerger.`reject(Diff diff, boolean rightToLeft)` Reject the given difference.
`protected void` ReferenceChangeMerger.`reject(Diff diff, boolean rightToLeft)` Merge the given difference rejecting it.
`protected void` FeatureMapChangeMerger.`reject(Diff diff, boolean rightToLeft)` Reject the given difference.
`protected void` AttributeChangeMerger.`reject(Diff diff, boolean rightToLeft)` Reject the given difference.
`protected void` AbstractMerger.`reject(Diff diff, boolean rightToLeft)` Reject the given difference.
`protected void` CachingDiffRelationshipComputer.`setCachedDirectMergeDependencies(Diff diff, boolean mergeRightToLeft, Set<Diff> directMergeDependencies)` Caches the given direct merge dependencies.
`protected void` CachingDiffRelationshipComputer.`setCachedDirectResultingMerges(Diff diff, boolean mergeRightToLeft, Set<Diff> directResultingMerges)` Caches the given direct resulting merges.
`protected void` CachingDiffRelationshipComputer.`setCachedDirectResultingRejections(Diff diff, boolean mergeRightToLeft, Set<Diff> directResultingRejections)` Caches the given direct resulting rejections.

Method parameters in org.eclipse.emf.compare.merge with type arguments of type Diff
`protected void` ComputeDiffsToMerge.`addDiff(Diff diff, Set<Diff> consequences, Set<Diff> diffPath)` Recursively add the required diffs, then the diff itself, to the result.
`protected void` ComputeDiffsToMerge.`addDiff(Diff diff, Set<Diff> consequences, Set<Diff> diffPath)` Recursively add the required diffs, then the diff itself, to the result.
`protected void` ComputeDiffsToMerge.`addDiffs(Collection<Diff> diffs, Set<Diff> diffPath)` Recursively add the given diffs to the result Set, starting by their requirements, then themselves, then their consequences, in the right order.
`protected void` ComputeDiffsToMerge.`addDiffs(Collection<Diff> diffs, Set<Diff> diffPath)` Recursively add the given diffs to the result Set, starting by their requirements, then themselves, then their consequences, in the right order.
`void` IBatchMerger.`copyAllLeftToRight(Iterable<? extends Diff> differences, Monitor monitor)` This will be called to copy all of the differences from the given list from the left to the right side.
`void` BatchMerger.`copyAllLeftToRight(Iterable<? extends Diff> differences, Monitor monitor)` This will be called to copy all of the differences from the given list from the left to the right side.
`void` IBatchMerger.`copyAllRightToLeft(Iterable<? extends Diff> differences, Monitor monitor)` This will be called to copy all of the differences from the given list from the right to the left side.
`void` BatchMerger.`copyAllRightToLeft(Iterable<? extends Diff> differences, Monitor monitor)` This will be called to copy all of the differences from the given list from the right to the left side.
`Set<Diff>` ComputeDiffsToMerge.`getAllDiffsToMerge(Iterable<? extends Diff> diffs)` Compute the ordered set of diffs to merge for the given diffs.
`Set<Diff>` IDiffRelationshipComputer.`getAllResultingMerges(Diff diff, boolean rightToLeft, com.google.common.base.Predicate<? super Diff> filter)` Retrieves the set of all diffs related to the given `diff` when merging in the given direction.
`Set<Diff>` DiffRelationshipComputer.`getAllResultingMerges(Diff diff, boolean rightToLeft, com.google.common.base.Predicate<? super Diff> filter)`
`Set<Diff>` IDiffRelationshipComputer.`getAllResultingRejections(Diff diff, boolean mergeRightToLeft, com.google.common.base.Predicate<? super Diff> filter)` Retrieves the set of all diffs that will be rejected if the given `diff` is merged, either because of unresolveable conflicts or because of unreachable requirements.
`Set<Diff>` DiffRelationshipComputer.`getAllResultingRejections(Diff diff, boolean mergeRightToLeft, com.google.common.base.Predicate<? super Diff> filter)`
`protected void` CachingDiffRelationshipComputer.`setCachedDirectMergeDependencies(Diff diff, boolean mergeRightToLeft, Set<Diff> directMergeDependencies)` Caches the given direct merge dependencies.
`protected void` CachingDiffRelationshipComputer.`setCachedDirectResultingMerges(Diff diff, boolean mergeRightToLeft, Set<Diff> directResultingMerges)` Caches the given direct resulting merges.
`protected void` CachingDiffRelationshipComputer.`setCachedDirectResultingRejections(Diff diff, boolean mergeRightToLeft, Set<Diff> directResultingRejections)` Caches the given direct resulting rejections.

Constructor parameters in org.eclipse.emf.compare.merge with type arguments of type Diff
Constructor and Description
`BatchMerger(IDiffRelationshipComputer relationshipComputer, com.google.common.base.Predicate<? super Diff> filter)` Constructs our batch merger provided the registry from which to retrieve the delegate mergers, and a filter if you only wish to merge specific differences.
`BatchMerger(IMerger.Registry registry, com.google.common.base.Predicate<? super Diff> filter)` Constructs our batch merger provided the registry from which to retrieve the delegate mergers, and a filter if you only wish to merge specific differences.
`MergeBlockedByConflictException(Collection<Diff> conflictingDiffs)` Constructor.

### Uses of Diff in org.eclipse.emf.compare.provider.spec

Methods in org.eclipse.emf.compare.provider.spec with parameters of type Diff
`Object` OverlayImageProvider.`getComposedImage(Diff diff, Object imageToCompose)` Returns a composed image with the image of the given diff the appropriate overlay.

### Uses of Diff in org.eclipse.emf.compare.rcp.ui.internal.contentmergeviewer

Methods in org.eclipse.emf.compare.rcp.ui.internal.contentmergeviewer with parameters of type Diff
`boolean` SingleValuedAttributeModelUpdateStrategy.`canUpdate(Diff diff, IMergeViewer.MergeViewerSide side)` Specifies whether the value in the model can to be updated on the given `side`.
`boolean` IModelUpdateStrategy.`canUpdate(Diff diff, IMergeViewer.MergeViewerSide side)` Specifies whether the value in the model can to be updated on the given `side`.
`Command` SingleValuedAttributeModelUpdateStrategy.`getModelUpdateCommand(Diff diff, Object newValue, IMergeViewer.MergeViewerSide side)` Returns a command for updating the underlying model with the given `newValue` on the given `side`.
`Command` IModelUpdateStrategy.`getModelUpdateCommand(Diff diff, Object newValue, IMergeViewer.MergeViewerSide side)` Returns a command for updating the underlying model with the given `newValue` on the given `side`.

### Uses of Diff in org.eclipse.emf.compare.rcp.ui.internal.contentmergeviewer.accessor.impl

Methods in org.eclipse.emf.compare.rcp.ui.internal.contentmergeviewer.accessor.impl that return Diff
`protected Diff` AbstractStructuralFeatureAccessor.`getInitialDiff()` Returns the initial diff associated with this accessor.

Methods in org.eclipse.emf.compare.rcp.ui.internal.contentmergeviewer.accessor.impl that return types with arguments of type Diff
`protected com.google.common.collect.ImmutableList<Diff>` ContainmentReferenceChangeAccessorImpl.`computeDifferences()` Compute the differences that apply on the structural feature.
`protected com.google.common.collect.ImmutableList<Diff>` AbstractStructuralFeatureAccessor.`computeDifferences()` Compute the differences that apply on the structural feature.
`protected com.google.common.collect.ImmutableList<Diff>` AbstractStructuralFeatureAccessor.`getDifferences()` Returns the list of diff that apply on the structural feature.

Methods in org.eclipse.emf.compare.rcp.ui.internal.contentmergeviewer.accessor.impl with parameters of type Diff
`protected int` ManyStructuralFeatureAccessorImpl.`findInsertionIndex(Diff diff, boolean rightToLeft)` Find the insertion index for the given diff.
`protected EStructuralFeature` AbstractStructuralFeatureAccessor.`getAffectedFeature(Diff diff)` Returns the structural feature affected by the given diff, if any.
`protected Object` ManyStructuralFeatureAccessorImpl.`getDiffValue(Diff diff)` Returns either `ReferenceChange.getValue()`, `AttributeChange.getValue()` or a `FeatureMapChange.getValue()` depending on the runtime type of the give, `diff` or null otherwise.
`protected Object` ManyStructuralFeatureAccessorImpl.`getValueFromDiff(Diff diff, IMergeViewer.MergeViewerSide side)` Get the value of the given side associated to the given Diff.

Constructors in org.eclipse.emf.compare.rcp.ui.internal.contentmergeviewer.accessor.impl with parameters of type Diff
Constructor and Description
`AbstractStructuralFeatureAccessor(AdapterFactory adapterFactory, Diff diff, IMergeViewer.MergeViewerSide side)` Default constructor.
`ContainmentReferenceChangeAccessorImpl(AdapterFactory adapterFactory, Diff diff, IMergeViewer.MergeViewerSide side)` .
`ManyStructuralFeatureAccessorImpl(AdapterFactory adapterFactory, Diff diff, IMergeViewer.MergeViewerSide side)` Default constructor.
`MatchAccessor(AdapterFactory adapterFactory, Match match, Diff diff, IMergeViewer.MergeViewerSide side)` Creates a new object wrapping the given `eObject`.
`ResourceContentsAccessorImpl(AdapterFactory adapterFactory, Diff diff, IMergeViewer.MergeViewerSide side)` Default constructor.
`SingleStructuralFeatureAccessorImpl(AdapterFactory adapterFactory, Diff diff, IMergeViewer.MergeViewerSide side)` Default constructor.

### Uses of Diff in org.eclipse.emf.compare.rcp.ui.internal.mergeviewer

Methods in org.eclipse.emf.compare.rcp.ui.internal.mergeviewer with parameters of type Diff
`org.eclipse.swt.graphics.Color` CompareColorImpl.`getFillColor(Diff diff, boolean isThreeWay, boolean isIgnoreAncestor, boolean selected)` Return the color of the background of the decorator of the given `diff`.
`org.eclipse.swt.graphics.Color` CompareColorImpl.`getStrokeColor(Diff diff, boolean isThreeWay, boolean isIgnoreAncestor, boolean selected)` Return the color of the stroke of the decorator of the given `diff`.

### Uses of Diff in org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.impl

Methods in org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.impl that return Diff
`protected Diff` AbstractStructuredMergeViewer.`getDiff()` Returns the `diff` associated with the one `IMergeViewerItem` in the viewer's `selection`.

Methods in org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.impl with parameters of type Diff
`protected org.eclipse.jface.action.IAction` AbstractStructuredMergeViewer.`createAction(MergeMode mode, Diff diff)` Creates the action for merging the given diff via the specified mode.

### Uses of Diff in org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.item.impl

Methods in org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.item.impl that return Diff
`Diff` MergeViewerItem.`getDiff()`

Methods in org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.item.impl that return types with arguments of type Diff
`protected List<? extends Diff>` MergeViewerItem.`filteredDiffs(Iterable<? extends Diff> unfilteredDiffs, com.google.common.base.Predicate<? super EObject> predicate, IDifferenceGroupProvider groupProvider)` Deprecated.
`protected com.google.common.base.Predicate<Diff>` MergeViewerItem.`visibleInMergeViewer(com.google.common.base.Predicate<? super EObject> predicate, IDifferenceGroupProvider groupProvider)` Deprecated.

Method parameters in org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.item.impl with type arguments of type Diff
`protected List<IMergeViewerItem>` MergeViewerItem.`createInsertionPoints(Comparison comparison, EStructuralFeature eStructuralFeature, List<? extends IMergeViewerItem> values, List<? extends Diff> differences)` Deprecated.
`protected List<? extends Diff>` MergeViewerItem.`filteredDiffs(Iterable<? extends Diff> unfilteredDiffs, com.google.common.base.Predicate<? super EObject> predicate, IDifferenceGroupProvider groupProvider)` Deprecated.
`protected boolean` MergeViewerItem.`yieldsInsertionPoint(Iterable<Diff> diffs)` Deprecated.

Constructors in org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.item.impl with parameters of type Diff
Constructor and Description
`Container(Comparison comparison, Diff diff, Match match, IMergeViewer.MergeViewerSide side, AdapterFactory adapterFactory)` Deprecated.
`Container(Comparison comparison, Diff diff, Object left, Object right, Object ancestor, IMergeViewer.MergeViewerSide side, AdapterFactory adapterFactory)` Deprecated.
`MergeViewerItem(Comparison comparison, Diff diff, Match match, IMergeViewer.MergeViewerSide side, AdapterFactory adapterFactory)`
`MergeViewerItem(Comparison comparison, Diff diff, Object left, Object right, Object ancestor, IMergeViewer.MergeViewerSide side, AdapterFactory adapterFactory)`
`ResourceAttachmentChangeMergeViewerItem(Comparison comparison, Diff diff, Match match, IMergeViewer.MergeViewerSide side, AdapterFactory adapterFactory)`
`ResourceAttachmentChangeMergeViewerItem(Comparison comparison, Diff diff, Resource left, Resource right, Resource ancestor, IMergeViewer.MergeViewerSide side, AdapterFactory adapterFactory)`

### Uses of Diff in org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl

Fields in org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl with type parameters of type Diff
`static com.google.common.base.Predicate<? super Diff>` ThreeWayComparisonGroupProvider.`DEFAULT_DIFF_GROUP_FILTER_PREDICATE` The default predicate used to filter differences in difference groups.
`protected com.google.common.base.Predicate<? super Diff>` BasicDifferenceGroupImpl.`filter` The filter we'll use in order to filter the differences that are part of this group.

Methods in org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl that return types with arguments of type Diff
`EList<Diff>` ThreeWayComparisonGroupProvider.CompositeConflict.`getDifferences()` Returns an EList built by aggregating the diffs of all the aggregated conflicts.

Methods in org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl with parameters of type Diff
`protected void` ThreeWayComparisonGroupProvider.ConflictsGroupImpl.`addDiffNode(MatchNode matchNode, Diff diff)` In the conflicts group, we want to be able to see the ResourceAttachmentChanges.
`protected void` BasicDifferenceGroupImpl.`addDiffNode(MatchNode matchNode, Diff diff)` Add the diff in the given match.
`protected DiffNode` BasicDifferenceGroupImpl.`createDiffNode(Diff diff)` Create a diff node.
`protected Match` BasicDifferenceGroupImpl.`getTargetMatch(Diff diff)` Provide the Match that should directly contain the given diff.
`protected boolean` BasicDifferenceGroupImpl.`isContainmentRefChange(Diff diff)` Is it a containment reference change?
`protected boolean` ThreeWayComparisonGroupProvider.ConflictsGroupImpl.`mustDisplayAsDirectChildOfMatch(Diff diff)` In conflicts, a special case must be handled for refining diffs: If they are not part of the same conflict then they should not be in the same group as the refined diff.
`protected boolean` BasicDifferenceGroupImpl.`mustDisplayAsDirectChildOfMatch(Diff diff)` Does the given difference have to be displayed as direct child of a Match?

Constructor parameters in org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl with type arguments of type Diff
Constructor and Description
`BasicDifferenceGroupImpl(Comparison comparison, com.google.common.base.Predicate<? super Diff> filter, ECrossReferenceAdapter crossReferenceAdapter)` Instantiates this group given the comparison and filter that should be used in order to determine its list of differences.
`BasicDifferenceGroupImpl(Comparison comparison, com.google.common.base.Predicate<? super Diff> filter, String name, ECrossReferenceAdapter crossReferenceAdapter)` Instantiates this group given the comparison and filter that should be used in order to determine its list of differences.
`BasicDifferenceGroupImpl(Comparison comparison, com.google.common.base.Predicate<? super Diff> filter, String name, org.eclipse.swt.graphics.Image image, ECrossReferenceAdapter crossReferenceAdapter)` Instantiates this group given the comparison and filter that should be used in order to determine its list of differences.
`ConflictsGroupImpl(Comparison comparison, com.google.common.base.Predicate<? super Diff> filter, String name, ECrossReferenceAdapter crossReferenceAdapter)` .

### Uses of Diff in org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.nodes

Methods in org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.nodes that return Diff
`Diff` DiffNode.`getDiff()` Getter for the diff represented by this TreeNode.

Constructors in org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.nodes with parameters of type Diff
Constructor and Description
`DiffNode(Diff diff)` Constructor.

### Uses of Diff in org.eclipse.emf.compare.rcp.ui.internal.util

Methods in org.eclipse.emf.compare.rcp.ui.internal.util with parameters of type Diff
`static EStructuralFeature` MergeViewerUtil.`getAffectedFeature(Diff diff)`
`static Object` MergeViewerUtil.`getDiffValue(Diff diff)` Returns either `ReferenceChange.getValue()`, `AttributeChange.getValue()` or a `FeatureMapChange.getValue()` depending on the runtime type of the give `diff` or null otherwise.
`static Resource` MergeViewerUtil.`getResource(Comparison comparison, IMergeViewer.MergeViewerSide side, Diff diff)` Returns the current resource on the given side of the given comparison.
`static List<EObject>` MergeViewerUtil.`getResourceContents(Comparison comparison, IMergeViewer.MergeViewerSide side, Diff diff)` Returns the contents of the current resource on the given side of the given comparison.
`static Object` MergeViewerUtil.`getValueFromDiff(Diff diff, IMergeViewer.MergeViewerSide side)`
`static List<?>` MergeViewerUtil.`getValues(Diff diff, IMergeViewer.MergeViewerSide side)`
`static boolean` MergeViewerUtil.`isMarkAsMerged(Diff diff, IMergeViewerItem item, IEMFCompareConfiguration compareConfiguration)` Checks if the given diff is considered as a mark as merged diff.
`static boolean` MergeViewerUtil.`isVisibleInMergeViewer(Diff diff, IDifferenceGroupProvider groupProvider, com.google.common.base.Predicate<? super EObject> predicate)` Returns true if the given diff is displayed in an group as provided by the `groupProvider` and not filtered by the given filter `predicate`.

### Uses of Diff in org.eclipse.emf.compare.rcp.ui.mergeviewer

Methods in org.eclipse.emf.compare.rcp.ui.mergeviewer with parameters of type Diff
`org.eclipse.swt.graphics.Color` ICompareColor.`getFillColor(Diff diff, boolean isThreeWay, boolean isIgnoreAncestor, boolean selected)` Return the color of the background of the decorator of the given `diff`.
`org.eclipse.swt.graphics.Color` ICompareColor.`getStrokeColor(Diff diff, boolean isThreeWay, boolean isIgnoreAncestor, boolean selected)` Return the color of the stroke of the decorator of the given `diff`.

### Uses of Diff in org.eclipse.emf.compare.rcp.ui.mergeviewer.item

Methods in org.eclipse.emf.compare.rcp.ui.mergeviewer.item that return Diff
`Diff` IMergeViewerItem.`getDiff()` The Diff associated with the Item.

### Uses of Diff in org.eclipse.emf.compare.req

Methods in org.eclipse.emf.compare.req with parameters of type Diff
`protected void` DefaultReqEngine.`checkForRequiredDifferences(Comparison comparison, Diff difference)` Checks the potential required differences from the given `difference`.

### Uses of Diff in org.eclipse.emf.compare.util

Methods in org.eclipse.emf.compare.util with parameters of type Diff
`T` CompareSwitch.`caseDiff(Diff object)` Returns the result of interpreting the object as an instance of 'Diff'

### Uses of Diff in org.eclipse.emf.compare.utils

Fields in org.eclipse.emf.compare.utils with type parameters of type Diff
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`CONTAINMENT_REFERENCE_CHANGE` This can be used to check whether a given diff is a containment reference change.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`WITHOUT_CONFLICT` This can be used to test whether a given Diff has no conflict object associated.

Methods in org.eclipse.emf.compare.utils that return types with arguments of type Diff
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`added(String qualifiedName)` This predicate can be used to check whether a given Diff represents the addition of an EObject matching the given qualified name.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`addedToAttribute(String qualifiedName, String attributeName, Object addedValue)` This predicate can be used to check whether a given Diff represents the addition of a value in a multi-valued attribute going by `attributeName` on an EObject which name matches `qualifiedName`.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`addedToReference(String qualifiedName, String referenceName, String addedQualifiedName)` This predicate can be used to check whether a given Diff represents the addition of a value in a multi-valued reference going by `referenceName` on an EObject which name matches `qualifiedName`.

`static com.google.common.base.Predicate<? super Diff>`

EMFComparePredicates.`addedToReference(String qualifiedName, String referenceName, String addedQualifiedName, EStructuralFeature featureDelegateForAddedName)`
This predicate can be used to check whether a given Diff represents the addition of a value in a multi-valued reference going by `referenceName` on an EObject which name matches `qualifiedName`.

`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`allAtomicRefining(com.google.common.base.Predicate<? super Diff> predicate)` This predicate can be used to check whether a diff has refiningDiffs AND all these refining diffs fulfill the given predicate.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`anyRefined(com.google.common.base.Predicate<? super Diff> predicate)` This predicate can be used to check whether any refined diff of a given diff fulfills the given predicate.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`anyRefining(com.google.common.base.Predicate<? super Diff> predicate)` This predicate can be used to check whether any refining diff of a given diff fulfills the given predicate.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`attributeValueMatch(String attributeName, Object expectedValue, boolean multiValued)` This predicate can be used to check whether a given Diff describes an AttributeChange with the given `attributeName` and which changed value corresponds to the given `expectedValue`.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`canBeConsideredAsPseudoConflicting()` This predicate can be used to test if a diff is in a pseudo conflict.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`changedAttribute(String qualifiedName, String attributeName, Object fromValue, Object toValue)` This predicate can be used to check whether a given Diff represents the modification of a single-valued attribute going by the given `attributeName` on an EObject which name matches `qualifiedName`.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`changedReference(String qualifiedName, String referenceName, String fromQualifiedName, String toQualifiedName)` This predicate can be used to check whether a given Diff represents the modification of a single-valued reference going by the given `referenceName` on an EObject which name matches `qualifiedName`.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`containmentReferenceChange()` Deprecated. use `EMFComparePredicates.CONTAINMENT_REFERENCE_CHANGE`;
`static Iterable<Diff>` MatchUtil.`findAddOrDeleteContainmentDiffs(Match match)` Get the potential ReferenceChanges that represent add/delete containment differences in the parent Match of the given Match.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`fromSide(DifferenceSource source)` This can be used to check that a given Diff originates from the given `source` side.
`static Iterable<Diff>` DiffUtil.`getAssociatedDiffs(Diff diffRoot, Iterable<Diff> subDiffs, boolean leftToRight)` Deprecated.
`static com.google.common.base.Function<Diff,Iterable<Diff>>` DiffUtil.`getSubDiffs(boolean leftToRight)` Deprecated. When merging a `Diff`, returns the sub diffs of this given diff, and all associated diffs (see `DiffUtil#getAssociatedDiffs(Iterable, boolean, Diff)`) of these sub diffs.
`static com.google.common.base.Function<Diff,Iterable<Diff>>` DiffUtil.`getSubDiffs(boolean leftToRight)` Deprecated. When merging a `Diff`, returns the sub diffs of this given diff, and all associated diffs (see `DiffUtil#getAssociatedDiffs(Iterable, boolean, Diff)`) of these sub diffs.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`hasConflict(ConflictKind... kinds)` This can be used to check whether a given Diff has a conflict of one of the given type.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`hasDirectOrIndirectConflict(ConflictKind... kinds)` This predicate can be used to check whether a diff is in a conflict directly or indirectly.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`hasNoDirectOrIndirectConflict(ConflictKind... kinds)` This predicate can be used to check whether a diff is not in a conflict directly or indirectly.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`hasSameReferenceAs(ReferenceChange diff)` This predicate can be used to check whether a given Diff is a `ReferenceChange` with the same reference as the `diff` argument.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`hasState(DifferenceState... states)` This can be used to check whether a given Diff is in (one of) the given state(s).
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`isDiffOnEOppositeOf(ReferenceChange diff)` This predicate can be used to check whether a given Diff is a `ReferenceChange` representing the eOpposite of the `diff` argument.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`isEquivalentTo(Diff diff)` This predicate can be used to check whether a given Diff is equivalent to the `diff` argument.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`isInRealAddAddConflict()` Indicates whether a diff is part of a real add/add conflict.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`isNotRefinedDirectlyConflicting(ConflictKind... kinds)` Check whether a diff is not refined and has a direct conflict of (one of) the given type(s).
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`moved(String qualifiedName, String referenceName)` This predicate can be used to check whether a given Diff represents the move of an EObject matching the given qualified name.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`movedInAttribute(String qualifiedName, String attributeName, Object removedValue)` This predicate can be used to check whether a given Diff represents the moving of a value within a multi-valued attribute going by `attributeName` on an EObject which name matches `qualifiedName`.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`movedInReference(String qualifiedName, String referenceName, String removedQualifiedName)` This predicate can be used to check whether a given Diff represents the moving of a value within a multi-valued reference going by `referenceName` on an EObject which name matches `qualifiedName`.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`ofKind(DifferenceKind kind)` This predicate can be used to check whether a particular diff is of the given `kind`.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`ofKind(DifferenceKind kind1, DifferenceKind kind2)` Accept only diffs of the given kinds.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`onEObject(EObject eObject)` This can be used in order to check that a Diff has been detected on the given EObject.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`onEObject(String qualifiedName)` This can be used in order to check whether a Diff has been detected on an EObject matching the given qualified name.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`onEObject(String qualifiedName, EStructuralFeature featureDelegate)` This can be used in order to check whether a Diff has been detected on an EObject matching the given qualified name or the qualified name under the given feature.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`onFeature(EStructuralFeature feature)` Accept only diffs that inherit either AttributeChange, ReferenceChange, or FeatureMapChange that concern the given feature.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`onFeature(String featureName)` This can be used to check that a given Diff correspond to either an `AttributeChange`, a `FeatureMapChange` or a `ReferenceChange`, and that the corresponding reference or attribute matches the given `featureName`.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`possiblyConflictingWith(Diff diff)` Predicate builder for diffs that can conflict with the given diff.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`referenceValueMatch(String referenceName, String qualifiedName, boolean multiValued)` This predicate can be used to check whether a given Diff describes a ReferenceChange with the given `referenceName` and which changed value corresponds to the given `qualifiedName`.

`static com.google.common.base.Predicate<? super Diff>`

EMFComparePredicates.`referenceValueMatch(String referenceName, String qualifiedName, boolean multiValued, EStructuralFeature featureDelegate)`
This predicate can be used to check whether a given Diff describes a ReferenceChange with the given `referenceName` and which changed value corresponds to the given `qualifiedName` or the qualified name under the given `featureDelegate`.

`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`removed(String qualifiedName)` This predicate can be used to check whether a given Diff represents the removal of an EObject matching the given qualified name.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`removedFromAttribute(String qualifiedName, String attributeName, Object removedValue)` This predicate can be used to check whether a given Diff represents the deletion of a value from a multi-valued attribute going by `attributeName` on an EObject which name matches `qualifiedName`.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`removedFromReference(String qualifiedName, String referenceName, String removedQualifiedName)` This predicate can be used to check whether a given Diff represents the deletion of a value from a multi-valued reference going by `referenceName` on an EObject which name matches `qualifiedName`.

`static com.google.common.base.Predicate<? super Diff>`

EMFComparePredicates.`removedFromReference(String qualifiedName, String referenceName, String removedQualifiedName, EStructuralFeature featureDelegateForRemovedName)`
This predicate can be used to check whether a given Diff represents the deletion of a value from a multi-valued reference going by `referenceName` on an EObject which name matches `qualifiedName`.

`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`sameSideAs(Diff diff)` This can be used to check that a given Diff originates from the given `source` side.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`valueIs(Object expectedValue)` This predicate can be used in order to check that a particular Diff describes either a `ReferenceChange`, `AttributeChange` or `FeatureMapChange` for the given `expectedValue`.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`valueMatches(IEqualityHelper helper, Object value)` Accept only diffs whose value matches the given value.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`valueNameMatches(String expectedName)` This can be used to check whether a given Diff describes either a `ReferenceChange` on an EObject which name is `expectedName`.
`static com.google.common.base.Predicate<? super Diff>` EMFComparePredicates.`valueNameMatches(String expectedName, EStructuralFeature featureDelegate)` This can be used to check whether a given Diff describes either a `ReferenceChange` on an EObject which name is `expectedName` or which the given feature provides the `expectedName`.

Methods in org.eclipse.emf.compare.utils with parameters of type Diff
`static int` DiffUtil.`findInsertionIndex(Comparison comparison, Diff diff, boolean rightToLeft)` Deprecated. This is the main entry point for `#findInsertionIndex(Comparison, EqualityHelper, Iterable, List, List, Object)`.
`static Iterable<Diff>` DiffUtil.`getAssociatedDiffs(Diff diffRoot, Iterable<Diff> subDiffs, boolean leftToRight)` Deprecated.
`static EObject` MatchUtil.`getContainer(Comparison comparison, Diff difference)` Get the business model object containing the given `difference`.
`static EObject` MatchUtil.`getOriginContainer(Comparison comparison, Diff difference)` Get the business model object containing the given `difference` in the origin side.
`static EStructuralFeature` MatchUtil.`getStructuralFeature(Diff input)` Get the structural feature of any difference.
`static Object` MatchUtil.`getValue(Diff input)` Get the value of any difference.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`isEquivalentTo(Diff diff)` This predicate can be used to check whether a given Diff is equivalent to the `diff` argument.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`possiblyConflictingWith(Diff diff)` Predicate builder for diffs that can conflict with the given diff.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`sameSideAs(Diff diff)` This can be used to check that a given Diff originates from the given `source` side.

Method parameters in org.eclipse.emf.compare.utils with type arguments of type Diff
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`allAtomicRefining(com.google.common.base.Predicate<? super Diff> predicate)` This predicate can be used to check whether a diff has refiningDiffs AND all these refining diffs fulfill the given predicate.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`anyRefined(com.google.common.base.Predicate<? super Diff> predicate)` This predicate can be used to check whether any refined diff of a given diff fulfills the given predicate.
`static com.google.common.base.Predicate<Diff>` EMFComparePredicates.`anyRefining(com.google.common.base.Predicate<? super Diff> predicate)` This predicate can be used to check whether any refining diff of a given diff fulfills the given predicate.
`static Iterable<Diff>` DiffUtil.`getAssociatedDiffs(Diff diffRoot, Iterable<Diff> subDiffs, boolean leftToRight)` Deprecated.