Package org.eclipse.emf.compare.merge

## Class CachingDiffRelationshipComputer

- java.lang.Object
- - org.eclipse.emf.compare.merge.DiffRelationshipComputer
  - - org.eclipse.emf.compare.merge.CachingDiffRelationshipComputer

All Implemented Interfaces:
  `IDiffRelationshipComputer`

    public class CachingDiffRelationshipComputer
    extends DiffRelationshipComputer

A computer implementation to cache the relationship of diffs. Note that the "all" relationships are not cached because they would O(n^2) memory in the general case.

Since:
  3.5
See Also:
  `IMerger2`

### Field Summary

Fields
`protected Map<Diff,​Set<Diff>>` `directMergeDependenciesL2R` Direct merge dependencies: left to right.
`protected Map<Diff,​Set<Diff>>` `directMergeDependenciesR2L` Direct merge dependencies: right to left.
`protected Map<Diff,​Set<Diff>>` `directResultingMergesL2R` Direct resulting merges: left to right.
`protected Map<Diff,​Set<Diff>>` `directResultingMergesR2L` Direct resulting merges: right to left.
`protected Map<Diff,​Set<Diff>>` `directResultingRejectionsL2R` Direct resulting rejections: left to right.
`protected Map<Diff,​Set<Diff>>` `directResultingRejectionsR2L` Direct resulting rejections: right to left.

### Fields inherited from class org.eclipse.emf.compare.merge.DiffRelationshipComputer

`criterion, registry`

### Constructor Summary

Constructors
`CachingDiffRelationshipComputer​(IMerger.Registry registry)` Creates a new computer with the given registry.
`CachingDiffRelationshipComputer​(IMerger.Registry registry, IMergeCriterion criterion)` Creates a new computer with the given registry and merge criterion.

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `computeCache​(Diff diff)` Computes the cached relationships for the give diff.
`protected Set<Diff>` `computeDirectMergeDependencies​(Diff diff, boolean mergeRightToLeft)` Computes direct merge dependencies for the given diff.
`protected Set<Diff>` `computeDirectResultingMerges​(Diff diff, boolean mergeRightToLeft)` Computes direct resulting merges for the given diff.
`protected Set<Diff>` `computeDirectResultingRejections​(Diff diff, boolean mergeRightToLeft)` Computes the direct resulting rejections.
`protected Set<Diff>` `getCachedDirectMergeDependencies​(Diff diff, boolean mergeRightToLeft)` Returns the cached direct merge dependencies.
`protected Set<Diff>` `getCachedDirectResultingMerges​(Diff diff, boolean mergeRightToLeft)` Returns the cached direct resulting merges.
`protected Set<Diff>` `getCachedDirectResultingRejections​(Diff diff, boolean mergeRightToLeft)` Returns the cached direct resulting rejections.
`Set<Diff>` `getDirectMergeDependencies​(Diff diff, boolean mergeRightToLeft)` Returns the cached direct merge dependencies, if present.
`Set<Diff>` `getDirectResultingMerges​(Diff diff, boolean mergeRightToLeft)` Returns the cached direct resulting merges, if present.
`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.
`void` `invalidate()` Invalidates the complete cache, so that relationships will be re-calculated any diff the next time a respective method is called.
`protected void` `setCachedDirectMergeDependencies​(Diff diff, boolean mergeRightToLeft, Set<Diff> directMergeDependencies)` Caches the given direct merge dependencies.
`protected void` `setCachedDirectResultingMerges​(Diff diff, boolean mergeRightToLeft, Set<Diff> directResultingMerges)` Caches the given direct resulting merges.
`protected void` `setCachedDirectResultingRejections​(Diff diff, boolean mergeRightToLeft, Set<Diff> directResultingRejections)` Caches the given direct resulting rejections.
`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.

### Methods inherited from class org.eclipse.emf.compare.merge.DiffRelationshipComputer

`getAllResultingMerges, getAllResultingMerges, getAllResultingRejections, getAllResultingRejections, getMergeCriterion, getMerger, getMergerRegistry, getMergerRegistry2, hasMerger, internalGetAllResultingMerges`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### directMergeDependenciesR2L

    protected Map<Diff,​Set<Diff>> directMergeDependenciesR2L

Direct merge dependencies: right to left.

#### directMergeDependenciesL2R

    protected Map<Diff,​Set<Diff>> directMergeDependenciesL2R

Direct merge dependencies: left to right.

#### directResultingMergesR2L

    protected Map<Diff,​Set<Diff>> directResultingMergesR2L

Direct resulting merges: right to left.

#### directResultingMergesL2R

    protected Map<Diff,​Set<Diff>> directResultingMergesL2R

Direct resulting merges: left to right.

#### directResultingRejectionsR2L

    protected Map<Diff,​Set<Diff>> directResultingRejectionsR2L

Direct resulting rejections: right to left.

#### directResultingRejectionsL2R

    protected Map<Diff,​Set<Diff>> directResultingRejectionsL2R

Direct resulting rejections: left to right.

### Constructor Detail

#### CachingDiffRelationshipComputer

    public CachingDiffRelationshipComputer​(IMerger.Registry registry)

Creates a new computer with the given registry.

Parameters:
  `registry` - merger registry

#### CachingDiffRelationshipComputer

    public CachingDiffRelationshipComputer​(IMerger.Registry registry,
                                           IMergeCriterion criterion)

Creates a new computer with the given registry and merge criterion.

Parameters:
  `registry` - merger registry
  `criterion` - merge criterion used to get the merger from the registry, use `IMergeCriterion.NONE` if no special criterion should be set.

### Method Detail

#### setMergerRegistry

    public void setMergerRegistry​(IMerger.Registry mergerRegistry)

Sets the merger registry used for calculating the diff relationships. WARNING: Setting the merger registry invalidates previously cached results, if another registry was set previously!

Specified by:
  `setMergerRegistry` in interface `IDiffRelationshipComputer`
Overrides:
  `setMergerRegistry` in class `DiffRelationshipComputer`
Parameters:
  `mergerRegistry` - The merger registry.

#### setMergeCriterion

    public void setMergeCriterion​(IMergeCriterion mergeCriterion)

Sets the merge criterion considered for calculating the diff relationships. WARNING: Setting the merge criterion invalidates previously cached results, if another criterion was set previously.

Specified by:
  `setMergeCriterion` in interface `IDiffRelationshipComputer`
Overrides:
  `setMergeCriterion` in class `DiffRelationshipComputer`
Parameters:
  `mergeCriterion` - The merger criterion.

#### setCachedDirectMergeDependencies

    protected void setCachedDirectMergeDependencies​(Diff diff,
                                                    boolean mergeRightToLeft,
                                                    Set<Diff> directMergeDependencies)

Caches the given direct merge dependencies.

Parameters:
  `diff` - diff
  `mergeRightToLeft` - merge direction
  `directMergeDependencies` - direct merge dependencies of diff

#### getCachedDirectMergeDependencies

    protected Set<Diff> getCachedDirectMergeDependencies​(Diff diff,
                                                         boolean mergeRightToLeft)

Returns the cached direct merge dependencies.

Parameters:
  `diff` - diff
  `mergeRightToLeft` - merge direction
Returns:
  cached direct merge dependencies

#### computeDirectMergeDependencies

    protected Set<Diff> computeDirectMergeDependencies​(Diff diff,
                                                       boolean mergeRightToLeft)

Computes direct merge dependencies for the given diff.

Parameters:
  `diff` - diff
  `mergeRightToLeft` - merge direction
Returns:
  a non-null set of direct merge dependencies

#### getDirectMergeDependencies

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

Returns the cached direct merge dependencies, if present. Otherwise, the direct merge dependencies are retrieved and cached using the given merger.

Specified by:
  `getDirectMergeDependencies` in interface `IDiffRelationshipComputer`
Overrides:
  `getDirectMergeDependencies` in class `DiffRelationshipComputer`
Parameters:
  `diff` - diff
  `mergeRightToLeft` - merge direction
Returns:
  cached direct merge dependencies
See Also:
  `IMerger2.getDirectMergeDependencies(Diff, boolean)`

#### setCachedDirectResultingMerges

    protected void setCachedDirectResultingMerges​(Diff diff,
                                                  boolean mergeRightToLeft,
                                                  Set<Diff> directResultingMerges)

Caches the given direct resulting merges.

Parameters:
  `diff` - diff
  `mergeRightToLeft` - merge direction
  `directResultingMerges` - direct resulting merges

#### getCachedDirectResultingMerges

    protected Set<Diff> getCachedDirectResultingMerges​(Diff diff,
                                                       boolean mergeRightToLeft)

Returns the cached direct resulting merges.

Parameters:
  `diff` - diff
  `mergeRightToLeft` - merge direction
Returns:
  cached direct resulting merges

#### computeDirectResultingMerges

    protected Set<Diff> computeDirectResultingMerges​(Diff diff,
                                                     boolean mergeRightToLeft)

Computes direct resulting merges for the given diff.

Parameters:
  `diff` - diff
  `mergeRightToLeft` - merge direction
Returns:
  a non-null set of all resulting merges

#### getDirectResultingMerges

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

Returns the cached direct resulting merges, if present. Otherwise, the direct resulting merges are retrieved and cached using the given merger.

Specified by:
  `getDirectResultingMerges` in interface `IDiffRelationshipComputer`
Overrides:
  `getDirectResultingMerges` in class `DiffRelationshipComputer`
Parameters:
  `diff` - diff
  `mergeRightToLeft` - merge direction
Returns:
  cached direct resulting merges
See Also:
  `IMerger2.getDirectResultingMerges(Diff, boolean)`

#### setCachedDirectResultingRejections

    protected void setCachedDirectResultingRejections​(Diff diff,
                                                      boolean mergeRightToLeft,
                                                      Set<Diff> directResultingRejections)

Caches the given direct resulting rejections.

Parameters:
  `diff` - diff
  `mergeRightToLeft` - merge direction
  `directResultingRejections` - direct resulting rejections

#### getCachedDirectResultingRejections

    protected Set<Diff> getCachedDirectResultingRejections​(Diff diff,
                                                           boolean mergeRightToLeft)

Returns the cached direct resulting rejections.

Parameters:
  `diff` - diff
  `mergeRightToLeft` - merge direction
Returns:
  cached direct resulting rejections

#### computeDirectResultingRejections

    protected Set<Diff> computeDirectResultingRejections​(Diff diff,
                                                         boolean mergeRightToLeft)

Computes the direct resulting rejections.

Parameters:
  `diff` - diff
  `mergeRightToLeft` - merge direction
Returns:
  a non-null set of direct resulting rejections

#### getDirectResultingRejections

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

Description copied from interface: `IDiffRelationshipComputer`
Returns the set of all differences that need to be rejected if `diff` is merged in the given direction.

Specified by:
  `getDirectResultingRejections` in interface `IDiffRelationshipComputer`
Overrides:
  `getDirectResultingRejections` in class `DiffRelationshipComputer`
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:
  `IDiffRelationshipComputer.getAllResultingRejections(Diff, boolean)`, `IMerger2.getDirectResultingRejections(Diff, boolean)`

#### computeCache

    public void computeCache​(Diff diff)

Computes the cached relationships for the give diff.

Parameters:
  `diff` - the diff for which to cmpute the cached relationship.

#### invalidate

    public void invalidate()

Invalidates the complete cache, so that relationships will be re-calculated any diff the next time a respective method is called.