Modifier and Type | Interface and Description |
---|---|
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'
|
Modifier and Type | Method and Description |
---|---|
Diff |
CompareFactory.createDiff()
Returns a new object of class 'Diff'
|
Diff |
Diff.getPrimeRefining()
Returns the value of the 'Prime Refining' reference
|
Modifier and Type | Method and Description |
---|---|
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
|
Modifier and Type | Field and Description |
---|---|
protected List<? extends Diff> |
AbstractCopyCommand.differences
The list of differences we are to merge.
|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
protected void |
DefaultEquiEngine.checkForEquivalences(Comparison comparison,
Diff difference)
Checks the potential equivalence from the given
difference . |
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
protected void |
EMFResourceMappingMerger.doMergeForDiff(Monitor emfMonitor,
Set<URI> conflictingURIs,
Diff diff,
IDiffRelationshipComputer relationshipComputer) |
Modifier and Type | Method and Description |
---|---|
protected Set<URI> |
EMFResourceMappingMerger.collectConflictingResources(Iterator<Diff> diffIterator)
Iterates over the given diffs to collect the resources they impact.
|
Modifier and Type | Method and Description |
---|---|
Set<Diff> |
DependencyData.getRejections() |
Set<Diff> |
DependencyData.getRequires() |
Modifier and Type | Method and Description |
---|---|
Collection<TreeNode> |
DependencyData.getTreeNodes(Diff diff) |
Modifier and Type | Method and Description |
---|---|
protected Iterable<Diff> |
MergeContainedNonConflictingAction.getSelectedDifferences(org.eclipse.jface.viewers.IStructuredSelection selection) |
protected Iterable<Diff> |
MergeAction.getSelectedDifferences(org.eclipse.jface.viewers.IStructuredSelection selection) |
Iterable<Diff> |
MergeNonConflictingRunnable.merge(Comparison comparison,
boolean leftToRight,
IMerger.Registry mergerRegistry)
Merges all non-conflicting differences from the given comparison in either direction.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
protected void |
MergeNonConflictingRunnable.doMergeDiffWithConflicts(boolean leftToRight,
IMerger.Registry mergerRegistry,
List<Diff> affectedDiffs,
Monitor emfMonitor,
Diff diff) |
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.
|
Modifier and Type | Class and Description |
---|---|
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'
|
Modifier and Type | Field and Description |
---|---|
protected Diff |
DiffImpl.primeRefining
The cached value of the ' Prime Refining ' reference.
|
Modifier and Type | Field and Description |
---|---|
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 |
Modifier and Type | Method and Description |
---|---|
Diff |
DiffImpl.basicGetPrimeRefining() |
Diff |
CompareFactoryImpl.createDiff() |
Diff |
DiffImpl.getPrimeRefining() |
Modifier and Type | Method and Description |
---|---|
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() |
Modifier and Type | Class and Description |
---|---|
class |
AbstractConflictSearch<T extends Diff>
Class in charge of finding conflicting diffs for a given diff of type T.
|
Modifier and Type | Field and Description |
---|---|
protected T |
AbstractConflictSearch.diff
The difference, never
null . |
Modifier and Type | Method and Description |
---|---|
Diff |
DiffTreeIterator.next() |
Modifier and Type | Method and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
void |
DiffTreeIterator.setFilter(com.google.common.base.Predicate<? super Diff> filter)
Sets the criterion that Diffs must meet to be returned by this iterator.
|
Modifier and Type | Method and Description |
---|---|
Iterable<Diff> |
IMergeAllNonConflictingRunnable.merge(Comparison comparison,
boolean leftToRight,
IMerger.Registry mergerRegistry)
Merges all non-conflicting differences from the given comparison in either direction.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
Diff |
IChangeFactory.create(Diff input)
|
Diff |
AbstractChangeFactory.create(Diff input)
|
abstract Diff |
AbstractChangeFactory.createExtension()
It creates the graphical change extension.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
Diff |
IChangeFactory.create(Diff input)
|
Diff |
AbstractChangeFactory.create(Diff input)
|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Class and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
Iterable<Diff> |
MatchSpec.getAllDifferences()
Finds and returns all differences contained in this Match and its children, recursively
|
EList<Diff> |
ComparisonSpec.getDifferences()
Returns all differences
contained by this Comparison and its children.
|
EList<Diff> |
ComparisonSpec.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> |
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
|
Modifier and Type | Method and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Field and Description |
---|---|
protected Map<Diff,Set<Diff>> |
CachingDiffRelationshipComputer.allResultingMergesL2R
All resulting merges: left to right.
|
protected Map<Diff,Set<Diff>> |
CachingDiffRelationshipComputer.allResultingMergesL2R
All resulting merges: left to right.
|
protected Map<Diff,Set<Diff>> |
CachingDiffRelationshipComputer.allResultingMergesR2L
All resulting merges: right to left.
|
protected Map<Diff,Set<Diff>> |
CachingDiffRelationshipComputer.allResultingMergesR2L
All resulting merges: right to left.
|
protected Map<Diff,Set<Diff>> |
CachingDiffRelationshipComputer.allResultingRejectionsL2R
All resulting rejections: left to right.
|
protected Map<Diff,Set<Diff>> |
CachingDiffRelationshipComputer.allResultingRejectionsL2R
All resulting rejections: left to right.
|
protected Map<Diff,Set<Diff>> |
CachingDiffRelationshipComputer.allResultingRejectionsR2L
All resulting rejections: right to left.
|
protected Map<Diff,Set<Diff>> |
CachingDiffRelationshipComputer.allResultingRejectionsR2L
All resulting rejections: right to left.
|
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.
|
Modifier and Type | Method and Description |
---|---|
protected Set<Diff> |
CachingDiffRelationshipComputer.computeAllResultingMerges(Diff diff,
boolean mergeRightToLeft)
Computes all resulting merges for the given diff.
|
protected Set<Diff> |
CachingDiffRelationshipComputer.computeAllResultingRejections(Diff diff,
boolean mergeRightToLeft)
Computes all resulting rejections for the given 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> |
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> |
CachingDiffRelationshipComputer.getAllResultingMerges(Diff diff,
boolean mergeRightToLeft)
Returns the cached direct resulting merges, if present.
|
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> |
CachingDiffRelationshipComputer.getAllResultingRejections(Diff diff,
boolean mergeRightToLeft) |
protected Set<Diff> |
CachingDiffRelationshipComputer.getCachedAllResultingMerges(Diff diff,
boolean mergeRightToLeft)
Returns the cached all resulting merges.
|
protected Set<Diff> |
CachingDiffRelationshipComputer.getCachedAllResultingRejections(Diff diff,
boolean mergeRightToLeft)
Returns the cached all resulting rejections.
|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
protected Set<Diff> |
CachingDiffRelationshipComputer.computeAllResultingMerges(Diff diff,
boolean mergeRightToLeft)
Computes all resulting merges for the given diff.
|
protected Set<Diff> |
CachingDiffRelationshipComputer.computeAllResultingRejections(Diff diff,
boolean mergeRightToLeft)
Computes all resulting rejections for the given 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> |
CachingDiffRelationshipComputer.getAllResultingMerges(Diff diff,
boolean mergeRightToLeft)
Returns the cached direct resulting merges, if present.
|
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> |
CachingDiffRelationshipComputer.getAllResultingRejections(Diff diff,
boolean mergeRightToLeft) |
protected Set<Diff> |
CachingDiffRelationshipComputer.getCachedAllResultingMerges(Diff diff,
boolean mergeRightToLeft)
Returns the cached all resulting merges.
|
protected Set<Diff> |
CachingDiffRelationshipComputer.getCachedAllResultingRejections(Diff diff,
boolean mergeRightToLeft)
Returns the cached all resulting rejections.
|
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) |
IMerger2 |
CachingDiffRelationshipComputer.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) |
boolean |
CachingDiffRelationshipComputer.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.
|
void |
CachingDiffRelationshipComputer.invalidate(Diff diff)
Invalidates the cache for the given diff, so that relationships will be re-calculated for this diff the
next time a respective method is called.
|
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.setCachedAllResultingMerges(Diff diff,
boolean mergeRightToLeft,
Set<Diff> allResultingMerges)
Caches the given all resulting merges.
|
protected void |
CachingDiffRelationshipComputer.setCachedAllResultingRejections(Diff diff,
boolean mergeRightToLeft,
Set<Diff> allResultingRejections)
Caches the given all resulting rejections.
|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
void |
CachingDiffRelationshipComputer.invalidate(Iterable<Diff> diffs)
Invalidates the cache for all given diffs, so that relationships will be re-calculated for each diff
the next time a respective method is called.
|
protected void |
CachingDiffRelationshipComputer.setCachedAllResultingMerges(Diff diff,
boolean mergeRightToLeft,
Set<Diff> allResultingMerges)
Caches the given all resulting merges.
|
protected void |
CachingDiffRelationshipComputer.setCachedAllResultingRejections(Diff diff,
boolean mergeRightToLeft,
Set<Diff> allResultingRejections)
Caches the given all resulting rejections.
|
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 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.
|
Modifier and Type | Method and Description |
---|---|
Object |
OverlayImageProvider.getComposedImage(Diff diff,
Object imageToCompose)
Returns a composed image with the image of the given diff the appropriate overlay.
|
Modifier and Type | Method and Description |
---|---|
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 . |
Modifier and Type | Method and Description |
---|---|
protected Diff |
AbstractStructuralFeatureAccessor.getInitialDiff()
Returns the initial diff associated with this accessor.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
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.
|
Modifier and Type | Method and Description |
---|---|
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 . |
Modifier and Type | Method and Description |
---|---|
Diff |
MergeViewerItem.getDiff() |
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Field and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
EList<Diff> |
ThreeWayComparisonGroupProvider.CompositeConflict.getDifferences()
Returns an EList built by aggregating the diffs of all the aggregated conflicts.
|
Modifier and Type | Method and Description |
---|---|
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 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)
.
|
Modifier and Type | Method and Description |
---|---|
Diff |
DiffNode.getDiff()
Getter for the diff represented by this TreeNode.
|
Constructor and Description |
---|
DiffNode(Diff diff)
Constructor.
|
Modifier and Type | Method and Description |
---|---|
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 . |
Modifier and Type | Method and Description |
---|---|
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 . |
Modifier and Type | Method and Description |
---|---|
Diff |
IMergeViewerItem.getDiff()
The Diff associated with the Item.
|
Modifier and Type | Method and Description |
---|---|
protected void |
DefaultReqEngine.checkForRequiredDifferences(Comparison comparison,
Diff difference)
Checks the potential required differences from the given
difference . |
Modifier and Type | Method and Description |
---|---|
T |
CompareSwitch.caseDiff(Diff object)
Returns the result of interpreting the object as an instance of 'Diff'
|
Modifier and Type | Field and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
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 . |
Modifier and Type | Method and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
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.
|
Copyright (c) 2006, 2015 Obeo and others. All rights reserved.