org.eclipse.emf.compare.merge

## Interface IDiffRelationshipComputer

All Known Implementing Classes:
  CachingDiffRelationshipComputer, DiffRelationshipComputer

    public interface IDiffRelationshipComputer

A computer to retrieve the dependent diffs, resulting merges and resulting rejections for a diff.

Since:
  3.5
See Also:
  `IMerger2`

### Method Summary

All Methods Instance Methods Abstract Methods
`Set<Diff>` `getAllResultingMerges(Diff diff, boolean rightToLeft)` Retrieves the set of all diffs related to the given `diff` when merging in the given direction.
`Set<Diff>` `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>` `getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)` Retrieves the set of directly required diffs needed in order to merge the given `diff`.
`Set<Diff>` `getDirectResultingMerges(Diff diff, boolean mergeRightToLeft)` Returns all differences that will be merged because of our merging the given `diff`.
`Set<Diff>` `getDirectResultingRejections(Diff diff, boolean mergeRightToLeft)` Returns the set of all differences that need to be rejected if `diff` is merged in the given direction.
`IMergeCriterion` `getMergeCriterion()` Returns the merge criterion considered for calculating the diff relationships.
`IMerger2` `getMerger(Diff diff)` Returns the best-fitting merger for the given diff according to the `merger registry` and the `merge criterion`.
`IMerger.Registry` `getMergerRegistry()` Returns the merger registry used for calculating the diff relationships.
`boolean` `hasMerger(Diff diff)` Indicates whether a best-fitting merger for the given diff is available.
`void` `setMergeCriterion(IMergeCriterion mergeCriterion)` Sets the merge criterion considered for calculating the diff relationships.
`void` `setMergerRegistry(IMerger.Registry mergerRegistry)` Sets the merger registry used for calculating the diff relationships.

### Method Detail

#### getDirectMergeDependencies

    Set<Diff> getDirectMergeDependencies(Diff diff,
                                         boolean mergeRightToLeft)

Retrieves the set of directly required diffs needed in order to merge the given `diff`. This may includes the diff's requirements or any other diff that we need to merge before the given one.

Parameters:
  `diff` - The difference for which we seek the direct merge dependencies.
  `mergeRightToLeft` - The direction in which we're considering a merge.
Returns:
  A non-null set of direct merge dependencies.
See Also:
  `IMerger2.getDirectMergeDependencies(Diff, boolean)`

#### getDirectResultingMerges

    Set<Diff> getDirectResultingMerges(Diff diff,
                                       boolean mergeRightToLeft)

Returns all differences that will be merged because of our merging the given `diff`. This may include the diff's implications, the diff's equivalences, the diff's refinements or any other diff that we need to merge together with the given diff.

Parameters:
  `diff` - The difference for which we seek the direct merge dependencies.
  `mergeRightToLeft` - The direction in which we're considering a merge.
Returns:
  A non-null set of direct resulting merges.
See Also:
  `IMerger2.getDirectResultingMerges(Diff, boolean)`

#### getDirectResultingRejections

    Set<Diff> getDirectResultingRejections(Diff diff,
                                           boolean mergeRightToLeft)

Returns the set of all differences that need to be rejected if `diff` is merged in the given direction.

Parameters:
  `diff` - The difference for which we seek the direct resulting rejections.
  `mergeRightToLeft` - The direction in which we're considering a merge.
Returns:
  A non-null set of direct resulting rejections.
See Also:
  `getAllResultingRejections(Diff, boolean)`, `IMerger2.getDirectResultingRejections(Diff, boolean)`

#### getAllResultingMerges

    Set<Diff> getAllResultingMerges(Diff diff,
                                    boolean rightToLeft)

Retrieves the set of all diffs related to the given `diff` when merging in the given direction.

This is expected to return the set of all differences that will be need to merged along when a user wishes to merge `diff`, either because they are required by it or because they are implied by it one way or another.

Note that `diff` will be included in the returned set.

Also note that the resulting merges will contain the resulting rejections (diffs from the other side that will be rejected)

Parameters:
  `diff` - The difference for which we seek all related ones.
  `rightToLeft` - The direction in which we're considering a merge.
Returns:
  A non-null set of all diffs related to the given `diff` when merging in the given direction.

#### getAllResultingRejections

    Set<Diff> 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.

Parameters:
  `diff` - The difference for which we seek all opposite ones.
  `mergeRightToLeft` - The direction in which we're considering a merge.
Returns:
  A non-null set of all diffs that will be rejected if the given `diff` is merged in the given direction.

#### getMergerRegistry

    IMerger.Registry getMergerRegistry()

Returns the merger registry used for calculating the diff relationships.

Returns:
  The merger registry.

#### setMergerRegistry

    void setMergerRegistry(IMerger.Registry mergerRegistry)

Sets the merger registry used for calculating the diff relationships.

Parameters:
  `mergerRegistry` - The merger registry.

#### getMergeCriterion

    IMergeCriterion getMergeCriterion()

Returns the merge criterion considered for calculating the diff relationships.

Returns:
  The merge criterion.

#### setMergeCriterion

    void setMergeCriterion(IMergeCriterion mergeCriterion)

Sets the merge criterion considered for calculating the diff relationships.

Parameters:
  `mergeCriterion` - The merger criterion.

#### getMerger

    IMerger2 getMerger(Diff diff)

Returns the best-fitting merger for the given diff according to the `merger registry` and the `merge criterion`.

Parameters:
  `diff` - The difference for which we seek the merger.
Returns:
  The best-fitting merger for the given diff or null if no merger fits.

#### hasMerger

    boolean hasMerger(Diff diff)

Indicates whether a best-fitting merger for the given diff is available.

Parameters:
  `diff` - The difference for which we seek the merger.
Returns:
  Returns true if a best-fitting merger is available, false otherwise.