Class 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 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

      • 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
      • 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
      • 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
      • 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.